refactor: make git package handle all git operations (#38543)

before: gitrepo vs git packages after: git package fully handle all git operations by the way, use `WithRepo(repo)` instead of `WithDir(repo.Path)` to hide path details. benefits: 1. remove all unnecessary wrappers, developers no need to struggle with "which package should be used" 2. simplify code, RepositoryFacade can (will) be used everywhere, all "path" details are (will be) hidden
2026-07-22 09:01:25 +00:00 · 2026-07-21 00:07:38 +08:00
parent b8977eeb47
commit 9dc04289aa
214 changed files with 859 additions and 1301 deletions
--- a/modules/git/archive.go
+++ b/modules/git/archive.go
@@ -0,0 +1,81 @@
+// Copyright 2025 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package git
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"os"
+	"path"
+	"path/filepath"
+	"strings"
+
+	"gitea.dev/modules/git/gitcmd"
+	"gitea.dev/modules/setting"
+)
+
+// CreateArchive create archive content to the target path
+func CreateArchive(ctx context.Context, repo RepositoryFacade, repoName, format string, target io.Writer, commitID string, paths []string) error {
+	if format == "unknown" {
+		return fmt.Errorf("unknown format: %v", format)
+	}
+
+	cmd := gitcmd.NewCommand("archive")
+	if setting.Repository.PrefixArchiveFiles {
+		cmd.AddOptionFormat("--prefix=%s", strings.ToLower(repoName)+"/")
+	}
+	cmd.AddOptionFormat("--format=%s", format)
+	cmd.AddDynamicArguments(commitID)
+
+	for i := range paths {
+		// although "git archive" already ensures the paths won't go outside the repo, we still clean them here for safety
+		cmd.AddDynamicArguments(path.Clean(paths[i]))
+	}
+	return cmd.WithStdoutCopy(target).WithRepo(repo).RunWithStderr(ctx)
+}
+
+// CreateBundle create bundle content to the target path
+func CreateBundle(ctx context.Context, repo RepositoryFacade, commit string, out io.Writer) error {
+	// TODO: use the following steps instead of creating a temp file, also need to iterate and clean up outdated refs
+	// git update-ref refs/bundle/temp-{timestamp} {commit}
+	// git bundle create - refs/bundle/temp-{timestamp}
+	// git update-ref -d refs/bundle/temp-{timestamp}
+	tmp, cleanup, err := setting.AppDataTempDir("git-repo-content").MkdirTempRandom("gitea-bundle")
+	if err != nil {
+		return err
+	}
+	defer cleanup()
+
+	env := append(os.Environ(), "GIT_OBJECT_DIRECTORY="+filepath.Join(gitcmd.RepoLocalPath(repo), "objects"))
+	_, _, err = gitcmd.NewCommand("init", "--bare").WithDir(tmp).WithEnv(env).RunStdString(ctx)
+	if err != nil {
+		return err
+	}
+
+	_, _, err = gitcmd.NewCommand("reset", "--soft").AddDynamicArguments(commit).WithDir(tmp).WithEnv(env).RunStdString(ctx)
+	if err != nil {
+		return err
+	}
+
+	_, _, err = gitcmd.NewCommand("branch", "-m", "bundle").WithDir(tmp).WithEnv(env).RunStdString(ctx)
+	if err != nil {
+		return err
+	}
+
+	tmpFile := filepath.Join(tmp, "bundle")
+	_, _, err = gitcmd.NewCommand("bundle", "create").AddDynamicArguments(tmpFile, "bundle", "HEAD").WithDir(tmp).WithEnv(env).RunStdString(ctx)
+	if err != nil {
+		return err
+	}
+
+	fi, err := os.Open(tmpFile)
+	if err != nil {
+		return err
+	}
+	defer fi.Close()
+
+	_, err = io.Copy(out, fi)
+	return err
+}
--- a/modules/git/attribute/batch.go
+++ b/modules/git/attribute/batch.go
@@ -69,7 +69,7 @@ func NewBatchChecker(ctx context.Context, repo *git.Repository, treeish string,
 	checker.stdOut = lw

 	cmd.WithEnv(envs).
-		WithDir(repo.Path).
+		WithRepo(repo).
 		WithStdoutCopy(lw)

 	go func() {
--- a/modules/git/attribute/checker.go
+++ b/modules/git/attribute/checker.go
@@ -69,7 +69,7 @@ func CheckAttributes(ctx context.Context, gitRepo *git.Repository, treeish strin
 	defer cancel()

 	stdout, _, err := cmd.WithEnv(append(os.Environ(), envs...)).
-		WithDir(gitRepo.Path).
+		WithRepo(gitRepo).
 		RunStdBytes(ctx)
 	if err != nil {
 		return nil, fmt.Errorf("failed to run check-attr: %w", err)
--- a/modules/git/blame.go
+++ b/modules/git/blame.go
@@ -0,0 +1,207 @@
+// Copyright 2025 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package git
+
+import (
+	"bufio"
+	"bytes"
+	"context"
+	"io"
+
+	"gitea.dev/modules/git/gitcmd"
+	"gitea.dev/modules/setting"
+)
+
+func LineBlame(ctx context.Context, repo RepositoryFacade, revision, file string, line uint) (string, error) {
+	stdout, _, err := gitcmd.NewCommand("blame").WithRepo(repo).
+		AddOptionFormat("-L %d,%d", line, line).
+		AddOptionValues("-p", revision).
+		AddDashesAndList(file).
+		RunStdString(ctx)
+	return stdout, err
+}
+
+// BlamePart represents block of blame - continuous lines with one sha
+type BlamePart struct {
+	Sha          string
+	Lines        []string
+	PreviousSha  string
+	PreviousPath string
+}
+
+// BlameReader returns part of file blame one by one
+type BlameReader struct {
+	bufferedReader *bufio.Reader
+	done           chan error
+	lastSha        *string
+	ignoreRevsFile string
+	objectFormat   ObjectFormat
+	cleanupFuncs   []func()
+}
+
+func (r *BlameReader) UsesIgnoreRevs() bool {
+	return r.ignoreRevsFile != ""
+}
+
+// NextPart returns next part of blame (sequential code lines with the same commit)
+func (r *BlameReader) NextPart() (*BlamePart, error) {
+	var blamePart *BlamePart
+
+	if r.lastSha != nil {
+		blamePart = &BlamePart{
+			Sha:   *r.lastSha,
+			Lines: make([]string, 0),
+		}
+	}
+
+	const previousHeader = "previous "
+	var lineBytes []byte
+	var isPrefix bool
+	var err error
+
+	for err != io.EOF {
+		lineBytes, isPrefix, err = r.bufferedReader.ReadLine()
+		if err != nil && err != io.EOF {
+			return blamePart, err
+		}
+
+		if len(lineBytes) == 0 {
+			// isPrefix will be false
+			continue
+		}
+
+		var objectID string
+		objectFormatLength := r.objectFormat.FullLength()
+
+		if len(lineBytes) > objectFormatLength && lineBytes[objectFormatLength] == ' ' && r.objectFormat.IsValid(string(lineBytes[0:objectFormatLength])) {
+			objectID = string(lineBytes[0:objectFormatLength])
+		}
+		if len(objectID) > 0 {
+			if blamePart == nil {
+				blamePart = &BlamePart{
+					Sha:   objectID,
+					Lines: make([]string, 0),
+				}
+			}
+
+			if blamePart.Sha != objectID {
+				r.lastSha = &objectID
+				// need to munch to end of line...
+				for isPrefix {
+					_, isPrefix, err = r.bufferedReader.ReadLine()
+					if err != nil && err != io.EOF {
+						return blamePart, err
+					}
+				}
+				return blamePart, nil
+			}
+		} else if lineBytes[0] == '\t' {
+			blamePart.Lines = append(blamePart.Lines, string(lineBytes[1:]))
+		} else if bytes.HasPrefix(lineBytes, []byte(previousHeader)) {
+			offset := len(previousHeader) // already includes a space
+			blamePart.PreviousSha = string(lineBytes[offset : offset+objectFormatLength])
+			offset += objectFormatLength + 1 // +1 for space
+			blamePart.PreviousPath = string(lineBytes[offset:])
+		}
+
+		// need to munch to end of line...
+		for isPrefix {
+			_, isPrefix, err = r.bufferedReader.ReadLine()
+			if err != nil && err != io.EOF {
+				return blamePart, err
+			}
+		}
+	}
+
+	r.lastSha = nil
+
+	return blamePart, nil
+}
+
+// Close BlameReader - don't run NextPart after invoking that
+func (r *BlameReader) Close() error {
+	if r.bufferedReader == nil {
+		return nil
+	}
+
+	err := <-r.done
+	r.bufferedReader = nil
+	r.cleanup()
+	return err
+}
+
+func (r *BlameReader) cleanup() {
+	for _, cleanup := range r.cleanupFuncs {
+		cleanup()
+	}
+}
+
+// CreateBlameReader creates reader for given git.RepositoryFacade, commit and file
+func CreateBlameReader(ctx context.Context, objectFormat ObjectFormat, repo RepositoryFacade, gitRepo *Repository, commit *Commit, file string, bypassBlameIgnore bool) (rd *BlameReader, retErr error) {
+	defer func() {
+		if retErr != nil {
+			rd.cleanup()
+		}
+	}()
+
+	rd = &BlameReader{
+		done:         make(chan error, 1),
+		objectFormat: objectFormat,
+	}
+
+	cmd := gitcmd.NewCommand("blame", "--porcelain")
+
+	stdoutReader, stdoutReaderClose := cmd.MakeStdoutPipe()
+	rd.bufferedReader = bufio.NewReader(stdoutReader)
+	rd.cleanupFuncs = append(rd.cleanupFuncs, stdoutReaderClose)
+
+	if DefaultFeatures().CheckVersionAtLeast("2.23") && !bypassBlameIgnore {
+		ignoreRevsFileName, ignoreRevsFileCleanup, err := tryCreateBlameIgnoreRevsFile(ctx, gitRepo, commit)
+		if err != nil && !IsErrNotExist(err) {
+			return nil, err
+		} else if err == nil {
+			rd.ignoreRevsFile = ignoreRevsFileName
+			rd.cleanupFuncs = append(rd.cleanupFuncs, ignoreRevsFileCleanup)
+			// Possible improvement: use --ignore-revs-file /dev/stdin on unix
+			// There is no equivalent on Windows. May be implemented if Gitea uses an external git backend.
+			cmd.AddOptionValues("--ignore-revs-file", ignoreRevsFileName)
+		}
+	}
+
+	cmd.AddDynamicArguments(commit.ID.String()).AddDashesAndList(file)
+
+	go func() {
+		// TODO: it doesn't work for directories (the directories shouldn't be "blamed"), and the "err" should be returned by "Read" but not by "Close"
+		rd.done <- cmd.WithRepo(repo).RunWithStderr(ctx)
+	}()
+
+	return rd, nil
+}
+
+func tryCreateBlameIgnoreRevsFile(ctx context.Context, gitRepo *Repository, commit *Commit) (string, func(), error) {
+	entry, err := commit.GetTreeEntryByPath(ctx, gitRepo, ".git-blame-ignore-revs")
+	if err != nil {
+		return "", nil, err
+	}
+
+	r, err := entry.Blob(gitRepo).DataAsync(ctx)
+	if err != nil {
+		return "", nil, err
+	}
+	defer r.Close()
+
+	f, cleanup, err := setting.AppDataTempDir("git-repo-content").CreateTempFileRandom("git-blame-ignore-revs")
+	if err != nil {
+		return "", nil, err
+	}
+	filename := f.Name()
+	_, err = io.Copy(f, r)
+	_ = f.Close()
+	if err != nil {
+		cleanup()
+		return "", nil, err
+	}
+
+	return filename, cleanup, nil
+}
--- a/modules/git/blame_sha256_test.go
+++ b/modules/git/blame_sha256_test.go
@@ -0,0 +1,155 @@
+// Copyright 2024 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package git
+
+import (
+	"context"
+	"testing"
+
+	"gitea.dev/modules/setting"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestReadingBlameOutputSha256(t *testing.T) {
+	setting.AppDataPath = t.TempDir()
+	ctx, cancel := context.WithCancel(t.Context())
+	defer cancel()
+
+	if DefaultFeatures().UsingGogit {
+		t.Skip("Skipping test since gogit does not support sha256")
+		return
+	}
+
+	t.Run("Without .git-blame-ignore-revs", func(t *testing.T) {
+		storage := mockRepository("repo5_pulls_sha256")
+		repo, err := OpenRepository(storage)
+		assert.NoError(t, err)
+		defer repo.Close()
+
+		commit, err := repo.GetCommit(t.Context(), "0b69b7bb649b5d46e14cabb6468685e5dd721290acc7ffe604d37cde57927345")
+		assert.NoError(t, err)
+
+		parts := []*BlamePart{
+			{
+				Sha: "1e35a51dc00fd7de730344c07061acfe80e8117e075ac979b6a29a3a045190ca",
+				Lines: []string{
+					"# test_repo",
+					"Test repository for testing migration from github to gitea",
+				},
+			},
+			{
+				Sha:          "0b69b7bb649b5d46e14cabb6468685e5dd721290acc7ffe604d37cde57927345",
+				Lines:        []string{"", "Do not make any changes to this repo it is used for unit testing"},
+				PreviousSha:  "1e35a51dc00fd7de730344c07061acfe80e8117e075ac979b6a29a3a045190ca",
+				PreviousPath: "README.md",
+			},
+		}
+
+		for _, bypass := range []bool{false, true} {
+			blameReader, err := CreateBlameReader(ctx, Sha256ObjectFormat, storage, repo, commit, "README.md", bypass)
+			assert.NoError(t, err)
+			assert.NotNil(t, blameReader)
+			defer blameReader.Close()
+
+			assert.False(t, blameReader.UsesIgnoreRevs())
+
+			for _, part := range parts {
+				actualPart, err := blameReader.NextPart()
+				assert.NoError(t, err)
+				assert.Equal(t, part, actualPart)
+			}
+
+			// make sure all parts have been read
+			actualPart, err := blameReader.NextPart()
+			assert.Nil(t, actualPart)
+			assert.NoError(t, err)
+		}
+	})
+
+	t.Run("With .git-blame-ignore-revs", func(t *testing.T) {
+		storage := mockRepository("repo6_blame_sha256")
+		repo, err := OpenRepository(storage)
+		assert.NoError(t, err)
+		defer repo.Close()
+
+		full := []*BlamePart{
+			{
+				Sha:   "ab2b57a4fa476fb2edb74dafa577caf918561abbaa8fba0c8dc63c412e17a7cc",
+				Lines: []string{"line", "line"},
+			},
+			{
+				Sha:          "9347b0198cd1f25017579b79d0938fa89dba34ad2514f0dd92f6bc975ed1a2fe",
+				Lines:        []string{"changed line"},
+				PreviousSha:  "ab2b57a4fa476fb2edb74dafa577caf918561abbaa8fba0c8dc63c412e17a7cc",
+				PreviousPath: "blame.txt",
+			},
+			{
+				Sha:   "ab2b57a4fa476fb2edb74dafa577caf918561abbaa8fba0c8dc63c412e17a7cc",
+				Lines: []string{"line", "line", ""},
+			},
+		}
+
+		cases := []struct {
+			CommitID       string
+			UsesIgnoreRevs bool
+			Bypass         bool
+			Parts          []*BlamePart
+		}{
+			{
+				CommitID:       "e2f5660e15159082902960af0ed74fc144921d2b0c80e069361853b3ece29ba3",
+				UsesIgnoreRevs: true,
+				Bypass:         false,
+				Parts: []*BlamePart{
+					{
+						Sha:   "ab2b57a4fa476fb2edb74dafa577caf918561abbaa8fba0c8dc63c412e17a7cc",
+						Lines: []string{"line", "line", "changed line", "line", "line", ""},
+					},
+				},
+			},
+			{
+				CommitID:       "e2f5660e15159082902960af0ed74fc144921d2b0c80e069361853b3ece29ba3",
+				UsesIgnoreRevs: false,
+				Bypass:         true,
+				Parts:          full,
+			},
+			{
+				CommitID:       "9347b0198cd1f25017579b79d0938fa89dba34ad2514f0dd92f6bc975ed1a2fe",
+				UsesIgnoreRevs: false,
+				Bypass:         false,
+				Parts:          full,
+			},
+			{
+				CommitID:       "9347b0198cd1f25017579b79d0938fa89dba34ad2514f0dd92f6bc975ed1a2fe",
+				UsesIgnoreRevs: false,
+				Bypass:         false,
+				Parts:          full,
+			},
+		}
+
+		objectFormat, err := repo.GetObjectFormat(t.Context())
+		assert.NoError(t, err)
+		for _, c := range cases {
+			commit, err := repo.GetCommit(t.Context(), c.CommitID)
+			assert.NoError(t, err)
+			blameReader, err := CreateBlameReader(ctx, objectFormat, storage, repo, commit, "blame.txt", c.Bypass)
+			assert.NoError(t, err)
+			assert.NotNil(t, blameReader)
+			defer blameReader.Close()
+
+			assert.Equal(t, c.UsesIgnoreRevs, blameReader.UsesIgnoreRevs())
+
+			for _, part := range c.Parts {
+				actualPart, err := blameReader.NextPart()
+				assert.NoError(t, err)
+				assert.Equal(t, part, actualPart)
+			}
+
+			// make sure all parts have been read
+			actualPart, err := blameReader.NextPart()
+			assert.Nil(t, actualPart)
+			assert.NoError(t, err)
+		}
+	})
+}
--- a/modules/git/blame_test.go
+++ b/modules/git/blame_test.go
@@ -0,0 +1,150 @@
+// Copyright 2019 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package git
+
+import (
+	"context"
+	"testing"
+
+	"gitea.dev/modules/setting"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestReadingBlameOutput(t *testing.T) {
+	setting.AppDataPath = t.TempDir()
+	ctx, cancel := context.WithCancel(t.Context())
+	defer cancel()
+
+	t.Run("Without .git-blame-ignore-revs", func(t *testing.T) {
+		storage := mockRepository("repo5_pulls")
+		repo, err := OpenRepository(storage)
+		assert.NoError(t, err)
+		defer repo.Close()
+		commit, err := repo.GetCommit(t.Context(), "f32b0a9dfd09a60f616f29158f772cedd89942d2")
+		assert.NoError(t, err)
+
+		parts := []*BlamePart{
+			{
+				Sha: "72866af952e98d02a73003501836074b286a78f6",
+				Lines: []string{
+					"# test_repo",
+					"Test repository for testing migration from github to gitea",
+				},
+			},
+			{
+				Sha:          "f32b0a9dfd09a60f616f29158f772cedd89942d2",
+				Lines:        []string{"", "Do not make any changes to this repo it is used for unit testing"},
+				PreviousSha:  "72866af952e98d02a73003501836074b286a78f6",
+				PreviousPath: "README.md",
+			},
+		}
+
+		for _, bypass := range []bool{false, true} {
+			blameReader, err := CreateBlameReader(ctx, Sha1ObjectFormat, storage, repo, commit, "README.md", bypass)
+			assert.NoError(t, err)
+			assert.NotNil(t, blameReader)
+			defer blameReader.Close()
+
+			assert.False(t, blameReader.UsesIgnoreRevs())
+
+			for _, part := range parts {
+				actualPart, err := blameReader.NextPart()
+				assert.NoError(t, err)
+				assert.Equal(t, part, actualPart)
+			}
+
+			// make sure all parts have been read
+			actualPart, err := blameReader.NextPart()
+			assert.Nil(t, actualPart)
+			assert.NoError(t, err)
+		}
+	})
+
+	t.Run("With .git-blame-ignore-revs", func(t *testing.T) {
+		storage := mockRepository("repo6_blame")
+		repo, err := OpenRepository(storage)
+		assert.NoError(t, err)
+		defer repo.Close()
+
+		full := []*BlamePart{
+			{
+				Sha:   "af7486bd54cfc39eea97207ca666aa69c9d6df93",
+				Lines: []string{"line", "line"},
+			},
+			{
+				Sha:          "45fb6cbc12f970b04eacd5cd4165edd11c8d7376",
+				Lines:        []string{"changed line"},
+				PreviousSha:  "af7486bd54cfc39eea97207ca666aa69c9d6df93",
+				PreviousPath: "blame.txt",
+			},
+			{
+				Sha:   "af7486bd54cfc39eea97207ca666aa69c9d6df93",
+				Lines: []string{"line", "line", ""},
+			},
+		}
+
+		cases := []struct {
+			CommitID       string
+			UsesIgnoreRevs bool
+			Bypass         bool
+			Parts          []*BlamePart
+		}{
+			{
+				CommitID:       "544d8f7a3b15927cddf2299b4b562d6ebd71b6a7",
+				UsesIgnoreRevs: true,
+				Bypass:         false,
+				Parts: []*BlamePart{
+					{
+						Sha:   "af7486bd54cfc39eea97207ca666aa69c9d6df93",
+						Lines: []string{"line", "line", "changed line", "line", "line", ""},
+					},
+				},
+			},
+			{
+				CommitID:       "544d8f7a3b15927cddf2299b4b562d6ebd71b6a7",
+				UsesIgnoreRevs: false,
+				Bypass:         true,
+				Parts:          full,
+			},
+			{
+				CommitID:       "45fb6cbc12f970b04eacd5cd4165edd11c8d7376",
+				UsesIgnoreRevs: false,
+				Bypass:         false,
+				Parts:          full,
+			},
+			{
+				CommitID:       "45fb6cbc12f970b04eacd5cd4165edd11c8d7376",
+				UsesIgnoreRevs: false,
+				Bypass:         false,
+				Parts:          full,
+			},
+		}
+
+		objectFormat, err := repo.GetObjectFormat(t.Context())
+		assert.NoError(t, err)
+		for _, c := range cases {
+			commit, err := repo.GetCommit(t.Context(), c.CommitID)
+			assert.NoError(t, err)
+
+			blameReader, err := CreateBlameReader(ctx, objectFormat, storage, repo, commit, "blame.txt", c.Bypass)
+			assert.NoError(t, err)
+			assert.NotNil(t, blameReader)
+			defer blameReader.Close()
+
+			assert.Equal(t, c.UsesIgnoreRevs, blameReader.UsesIgnoreRevs())
+
+			for _, part := range c.Parts {
+				actualPart, err := blameReader.NextPart()
+				assert.NoError(t, err)
+				assert.Equal(t, part, actualPart)
+			}
+
+			// make sure all parts have been read
+			actualPart, err := blameReader.NextPart()
+			assert.Nil(t, actualPart)
+			assert.NoError(t, err)
+		}
+	})
+}
--- a/modules/git/branch.go
+++ b/modules/git/branch.go
@@ -0,0 +1,95 @@
+// Copyright 2024 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package git
+
+import (
+	"context"
+	"errors"
+	"strings"
+
+	"gitea.dev/modules/git/gitcmd"
+)
+
+// GetBranchesByPath returns a branch by its path
+// if limit = 0 it will not limit
+func GetBranchesByPath(ctx context.Context, repo RepositoryFacade, skip, limit int) ([]string, int, error) {
+	gitRepo, err := OpenRepository(repo)
+	if err != nil {
+		return nil, 0, err
+	}
+	defer gitRepo.Close()
+
+	return gitRepo.GetBranchNames(ctx, skip, limit)
+}
+
+func GetBranchCommitID(ctx context.Context, repo RepositoryFacade, branch string) (string, error) {
+	gitRepo, err := OpenRepository(repo)
+	if err != nil {
+		return "", err
+	}
+	defer gitRepo.Close()
+
+	return gitRepo.GetBranchCommitID(ctx, branch)
+}
+
+// SetDefaultBranch sets default branch of repository.
+func SetDefaultBranch(ctx context.Context, repo RepositoryFacade, name string) error {
+	_, _, err := gitcmd.NewCommand("symbolic-ref", "HEAD").
+		AddDynamicArguments(BranchPrefix + name).WithRepo(repo).RunStdString(ctx)
+	return err
+}
+
+// GetDefaultBranch gets default branch of repository.
+func GetDefaultBranch(ctx context.Context, repo RepositoryFacade) (string, error) {
+	stdout, _, err := gitcmd.NewCommand("symbolic-ref", "HEAD").WithRepo(repo).RunStdString(ctx)
+	if err != nil {
+		return "", err
+	}
+	stdout = strings.TrimSpace(stdout)
+	if !strings.HasPrefix(stdout, BranchPrefix) {
+		return "", errors.New("the HEAD is not a branch: " + stdout)
+	}
+	return strings.TrimPrefix(stdout, BranchPrefix), nil
+}
+
+// IsReferenceExist returns true if given reference exists in the repository.
+func IsReferenceExist(ctx context.Context, repo RepositoryFacade, name string) bool {
+	_, _, err := gitcmd.NewCommand("show-ref", "--verify").AddDashesAndList(name).WithRepo(repo).RunStdString(ctx)
+	return err == nil
+}
+
+// IsBranchExist returns true if given branch exists in the repository.
+func IsBranchExist(ctx context.Context, repo RepositoryFacade, name string) bool {
+	return IsReferenceExist(ctx, repo, BranchPrefix+name)
+}
+
+// DeleteBranch delete a branch by name on repository.
+func DeleteBranch(ctx context.Context, repo RepositoryFacade, name string, force bool) error {
+	cmd := gitcmd.NewCommand("branch")
+
+	if force {
+		cmd.AddArguments("-D")
+	} else {
+		cmd.AddArguments("-d")
+	}
+
+	cmd.AddDashesAndList(name)
+	_, _, err := cmd.WithRepo(repo).RunStdString(ctx)
+	return err
+}
+
+// CreateBranch create a new branch
+func CreateBranch(ctx context.Context, repo RepositoryFacade, branch, oldbranchOrCommit string) error {
+	cmd := gitcmd.NewCommand("branch")
+	cmd.AddDashesAndList(branch, oldbranchOrCommit)
+
+	_, _, err := cmd.WithRepo(repo).RunStdString(ctx)
+	return err
+}
+
+// RenameBranch rename a branch
+func RenameBranch(ctx context.Context, repo RepositoryFacade, from, to string) error {
+	_, _, err := gitcmd.NewCommand("branch", "-m").AddDynamicArguments(from, to).WithRepo(repo).RunStdString(ctx)
+	return err
+}
--- a/modules/git/clone.go
+++ b/modules/git/clone.go
@@ -0,0 +1,24 @@
+// Copyright 2025 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package git
+
+import (
+	"context"
+
+	"gitea.dev/modules/git/gitcmd"
+)
+
+// CloneExternalRepo clones an external repository to the managed repository.
+func CloneExternalRepo(ctx context.Context, fromRemoteURL string, toRepo RepositoryFacade, opts CloneRepoOptions) error {
+	return Clone(ctx, fromRemoteURL, gitcmd.RepoLocalPath(toRepo), opts)
+}
+
+// CloneRepoToLocal clones a managed repository to a local path.
+func CloneRepoToLocal(ctx context.Context, fromRepo RepositoryFacade, toLocalPath string, opts CloneRepoOptions) error {
+	return Clone(ctx, gitcmd.RepoLocalPath(fromRepo), toLocalPath, opts)
+}
+
+func CloneManaged(ctx context.Context, fromRepo, toRepo RepositoryFacade, opts CloneRepoOptions) error {
+	return Clone(ctx, gitcmd.RepoLocalPath(fromRepo), gitcmd.RepoLocalPath(toRepo), opts)
+}
--- a/modules/git/commit.go
+++ b/modules/git/commit.go
@@ -112,7 +112,7 @@ func (c *Commit) HasPreviousCommit(ctx context.Context, gitRepo *Repository, obj

 	_, _, err := gitcmd.NewCommand("merge-base", "--is-ancestor").
 		AddDynamicArguments(that, this).
-		WithDir(gitRepo.Path).
+		WithRepo(gitRepo).
 		RunStdString(ctx)
 	if err == nil {
 		return true, nil
@@ -239,10 +239,10 @@ func (c *Commit) GetFileContent(ctx context.Context, gitRepo *Repository, filena
 }

 // GetFullCommitID returns full length (40) of commit ID by given short SHA in a repository.
-func GetFullCommitID(ctx context.Context, repoPath, shortID string) (string, error) {
+func GetFullCommitID(ctx context.Context, repo RepositoryFacade, shortID string) (string, error) {
 	commitID, _, err := gitcmd.NewCommand("rev-parse").
 		AddDynamicArguments(shortID).
-		WithDir(repoPath).
+		WithRepo(repo).
 		RunStdString(ctx)
 	if err != nil {
 		if gitcmd.IsErrorExitCode(err, 128) {
--- a/modules/git/commit2.go
+++ b/modules/git/commit2.go
@@ -0,0 +1,97 @@
+// Copyright 2025 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package git
+
+import (
+	"context"
+	"strconv"
+	"strings"
+	"time"
+
+	"gitea.dev/modules/git/gitcmd"
+)
+
+// CommitsCountOptions the options when counting commits
+type CommitsCountOptions struct {
+	Not      string
+	Revision []string
+	RelPath  []string
+	Since    string
+	Until    string
+}
+
+// CommitsCount returns number of total commits of until given revision.
+func CommitsCount(ctx context.Context, repo RepositoryFacade, opts CommitsCountOptions) (int64, error) {
+	cmd := gitcmd.NewCommand("rev-list", "--count")
+
+	cmd.AddDynamicArguments(opts.Revision...)
+
+	if opts.Not != "" {
+		cmd.AddOptionValues("--not", opts.Not)
+	}
+
+	if opts.Since != "" {
+		cmd.AddOptionFormat("--since=%s", opts.Since)
+	}
+
+	if opts.Until != "" {
+		cmd.AddOptionFormat("--until=%s", opts.Until)
+	}
+
+	if len(opts.RelPath) > 0 {
+		cmd.AddDashesAndList(opts.RelPath...)
+	}
+
+	stdout, _, err := cmd.WithRepo(repo).RunStdString(ctx)
+	if err != nil {
+		return 0, err
+	}
+
+	return strconv.ParseInt(strings.TrimSpace(stdout), 10, 64)
+}
+
+// FileCommitsCount return the number of files at a revision
+func FileCommitsCount(ctx context.Context, repo RepositoryFacade, revision, file string) (int64, error) {
+	return CommitsCount(ctx, repo,
+		CommitsCountOptions{
+			Revision: []string{revision},
+			RelPath:  []string{file},
+		})
+}
+
+// CommitsCountOfCommit returns number of total commits of until current revision.
+func CommitsCountOfCommit(ctx context.Context, repo RepositoryFacade, commitID string) (int64, error) {
+	return CommitsCount(ctx, repo, CommitsCountOptions{
+		Revision: []string{commitID},
+	})
+}
+
+// AllCommitsCount returns count of all commits in repository
+func AllCommitsCount(ctx context.Context, repo RepositoryFacade, hidePRRefs bool, files ...string) (int64, error) {
+	cmd := gitcmd.NewCommand("rev-list")
+	if hidePRRefs {
+		cmd.AddArguments("--exclude=" + PullPrefix + "*")
+	}
+	cmd.AddArguments("--all", "--count")
+	if len(files) > 0 {
+		cmd.AddDashesAndList(files...)
+	}
+
+	stdout, _, err := cmd.WithRepo(repo).RunStdString(ctx)
+	if err != nil {
+		return 0, err
+	}
+
+	return strconv.ParseInt(strings.TrimSpace(stdout), 10, 64)
+}
+
+// GetLatestCommitTime returns time for latest commit in repository (across all branches)
+func GetLatestCommitTime(ctx context.Context, repo RepositoryFacade) (time.Time, error) {
+	stdout, _, err := gitcmd.NewCommand("for-each-ref", "--sort=-committerdate", BranchPrefix, "--count", "1", "--format=%(committerdate)").WithRepo(repo).RunStdString(ctx)
+	if err != nil {
+		return time.Time{}, err
+	}
+	commitTime := strings.TrimSpace(stdout)
+	return time.Parse("Mon Jan _2 15:04:05 2006 -0700", commitTime)
+}
--- a/modules/git/commit2_test.go
+++ b/modules/git/commit2_test.go
@@ -0,0 +1,76 @@
+// Copyright 2025 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package git
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestCommitsCount(t *testing.T) {
+	bareRepo1 := mockRepository("repo1_bare")
+
+	commitsCount, err := CommitsCount(t.Context(), bareRepo1,
+		CommitsCountOptions{
+			Revision: []string{"8006ff9adbf0cb94da7dad9e537e53817f9fa5c0"},
+		})
+
+	assert.NoError(t, err)
+	assert.Equal(t, int64(3), commitsCount)
+}
+
+func TestCommitsCountWithSinceUntil(t *testing.T) {
+	bareRepo1 := mockRepository("repo1_bare")
+	revision := []string{"8006ff9adbf0cb94da7dad9e537e53817f9fa5c0"}
+
+	// The three commits on this revision are dated 2018-04-18, 2017-12-19 and 2017-12-19.
+	cases := []struct {
+		name     string
+		since    string
+		until    string
+		expected int64
+	}{
+		{name: "no filter", expected: 3},
+		{name: "since keeps newer commits", since: "2018-01-01", expected: 1},
+		{name: "until keeps older commits", until: "2018-01-01", expected: 2},
+		{name: "since and until bound the range", since: "2017-12-19T22:16:00-08:00", until: "2018-01-01", expected: 1},
+	}
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			commitsCount, err := CommitsCount(t.Context(), bareRepo1,
+				CommitsCountOptions{
+					Revision: revision,
+					Since:    tc.since,
+					Until:    tc.until,
+				})
+
+			assert.NoError(t, err)
+			assert.Equal(t, tc.expected, commitsCount)
+		})
+	}
+}
+
+func TestCommitsCountWithoutBase(t *testing.T) {
+	bareRepo1 := mockRepository("repo1_bare")
+
+	commitsCount, err := CommitsCount(t.Context(), bareRepo1,
+		CommitsCountOptions{
+			Not:      "master",
+			Revision: []string{"branch1"},
+		})
+
+	assert.NoError(t, err)
+	assert.Equal(t, int64(2), commitsCount)
+}
+
+func TestGetLatestCommitTime(t *testing.T) {
+	bareRepo1 := mockRepository("repo1_bare")
+	lct, err := GetLatestCommitTime(t.Context(), bareRepo1)
+	assert.NoError(t, err)
+	// Time is Sun Nov 13 16:40:14 2022 +0100
+	// which is the time of commit
+	// ce064814f4a0d337b333e646ece456cd39fab612 (refs/heads/master)
+	assert.EqualValues(t, 1668354014, lct.Unix())
+}
--- a/modules/git/commit_file.go
+++ b/modules/git/commit_file.go
@@ -0,0 +1,88 @@
+// Copyright 2025 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package git
+
+import (
+	"bufio"
+	"context"
+	"io"
+
+	"gitea.dev/modules/git/gitcmd"
+	"gitea.dev/modules/log"
+)
+
+// CommitFileStatus represents status of files in a commit.
+type CommitFileStatus struct {
+	Added    []string
+	Removed  []string
+	Modified []string
+}
+
+// NewCommitFileStatus creates a CommitFileStatus
+func NewCommitFileStatus() *CommitFileStatus {
+	return &CommitFileStatus{
+		[]string{}, []string{}, []string{},
+	}
+}
+
+func parseCommitFileStatus(fileStatus *CommitFileStatus, stdout io.Reader) {
+	rd := bufio.NewReader(stdout)
+	peek, err := rd.Peek(1)
+	if err != nil {
+		if err != io.EOF {
+			log.Error("Unexpected error whilst reading from git log --name-status. Error: %v", err)
+		}
+		return
+	}
+	if peek[0] == '\n' || peek[0] == '\x00' {
+		_, _ = rd.Discard(1)
+	}
+	for {
+		modifier, err := rd.ReadString('\x00')
+		if err != nil {
+			if err != io.EOF {
+				log.Error("Unexpected error whilst reading from git log --name-status. Error: %v", err)
+			}
+			return
+		}
+		file, err := rd.ReadString('\x00')
+		if err != nil {
+			if err != io.EOF {
+				log.Error("Unexpected error whilst reading from git log --name-status. Error: %v", err)
+			}
+			return
+		}
+		file = file[:len(file)-1]
+		switch modifier[0] {
+		case 'A':
+			fileStatus.Added = append(fileStatus.Added, file)
+		case 'D':
+			fileStatus.Removed = append(fileStatus.Removed, file)
+		case 'M':
+			fileStatus.Modified = append(fileStatus.Modified, file)
+		}
+	}
+}
+
+// GetCommitFileStatus returns file status of commit in given repository.
+func GetCommitFileStatus(ctx context.Context, repo RepositoryFacade, commitID string) (*CommitFileStatus, error) {
+	cmd := gitcmd.NewCommand("log", "--name-status", "-m", "--pretty=format:", "--first-parent", "--no-renames", "-z", "-1")
+	stdout, stdoutClose := cmd.MakeStdoutPipe()
+	defer stdoutClose()
+	done := make(chan struct{})
+	fileStatus := NewCommitFileStatus()
+	go func() {
+		parseCommitFileStatus(fileStatus, stdout)
+		close(done)
+	}()
+	err := cmd.AddDynamicArguments(commitID).
+		WithRepo(repo).
+		RunWithStderr(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	<-done
+	return fileStatus, nil
+}
--- a/modules/git/commit_file_test.go
+++ b/modules/git/commit_file_test.go
@@ -0,0 +1,175 @@
+// Copyright 2025 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package git
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestParseCommitFileStatus(t *testing.T) {
+	type testcase struct {
+		output   string
+		added    []string
+		removed  []string
+		modified []string
+	}
+
+	kases := []testcase{
+		{
+			// Merge commit
+			output: "MM\x00options/locale/locale_en-US.ini\x00",
+			modified: []string{
+				"options/locale/locale_en-US.ini",
+			},
+			added:   []string{},
+			removed: []string{},
+		},
+		{
+			// Spaces commit
+			output: "D\x00b\x00D\x00b b/b\x00A\x00b b/b b/b b/b\x00A\x00b b/b b/b b/b b/b\x00",
+			removed: []string{
+				"b",
+				"b b/b",
+			},
+			modified: []string{},
+			added: []string{
+				"b b/b b/b b/b",
+				"b b/b b/b b/b b/b",
+			},
+		},
+		{
+			// larger commit
+			output: "M\x00go.mod\x00M\x00go.sum\x00M\x00modules/ssh/ssh.go\x00M\x00vendor/github.com/gliderlabs/ssh/circle.yml\x00M\x00vendor/github.com/gliderlabs/ssh/context.go\x00A\x00vendor/github.com/gliderlabs/ssh/go.mod\x00A\x00vendor/github.com/gliderlabs/ssh/go.sum\x00M\x00vendor/github.com/gliderlabs/ssh/server.go\x00M\x00vendor/github.com/gliderlabs/ssh/session.go\x00M\x00vendor/github.com/gliderlabs/ssh/ssh.go\x00M\x00vendor/golang.org/x/sys/unix/mkerrors.sh\x00M\x00vendor/golang.org/x/sys/unix/syscall_darwin.go\x00M\x00vendor/golang.org/x/sys/unix/zerrors_darwin_amd64.go\x00M\x00vendor/golang.org/x/sys/unix/zerrors_darwin_arm64.go\x00M\x00vendor/golang.org/x/sys/unix/zerrors_freebsd_386.go\x00M\x00vendor/golang.org/x/sys/unix/zerrors_freebsd_amd64.go\x00M\x00vendor/golang.org/x/sys/unix/zerrors_freebsd_arm.go\x00M\x00vendor/golang.org/x/sys/unix/zerrors_freebsd_arm64.go\x00M\x00vendor/golang.org/x/sys/unix/zerrors_linux.go\x00M\x00vendor/golang.org/x/sys/unix/ztypes_darwin_amd64.go\x00M\x00vendor/golang.org/x/sys/unix/ztypes_darwin_arm64.go\x00M\x00vendor/golang.org/x/sys/unix/ztypes_dragonfly_amd64.go\x00M\x00vendor/golang.org/x/sys/unix/ztypes_freebsd_386.go\x00M\x00vendor/golang.org/x/sys/unix/ztypes_freebsd_amd64.go\x00M\x00vendor/golang.org/x/sys/unix/ztypes_freebsd_arm.go\x00M\x00vendor/golang.org/x/sys/unix/ztypes_freebsd_arm64.go\x00M\x00vendor/golang.org/x/sys/unix/ztypes_netbsd_386.go\x00M\x00vendor/golang.org/x/sys/unix/ztypes_netbsd_amd64.go\x00M\x00vendor/golang.org/x/sys/unix/ztypes_netbsd_arm.go\x00M\x00vendor/golang.org/x/sys/unix/ztypes_netbsd_arm64.go\x00M\x00vendor/modules.txt\x00",
+			modified: []string{
+				"go.mod",
+				"go.sum",
+				"modules/ssh/ssh.go",
+				"vendor/github.com/gliderlabs/ssh/circle.yml",
+				"vendor/github.com/gliderlabs/ssh/context.go",
+				"vendor/github.com/gliderlabs/ssh/server.go",
+				"vendor/github.com/gliderlabs/ssh/session.go",
+				"vendor/github.com/gliderlabs/ssh/ssh.go",
+				"vendor/golang.org/x/sys/unix/mkerrors.sh",
+				"vendor/golang.org/x/sys/unix/syscall_darwin.go",
+				"vendor/golang.org/x/sys/unix/zerrors_darwin_amd64.go",
+				"vendor/golang.org/x/sys/unix/zerrors_darwin_arm64.go",
+				"vendor/golang.org/x/sys/unix/zerrors_freebsd_386.go",
+				"vendor/golang.org/x/sys/unix/zerrors_freebsd_amd64.go",
+				"vendor/golang.org/x/sys/unix/zerrors_freebsd_arm.go",
+				"vendor/golang.org/x/sys/unix/zerrors_freebsd_arm64.go",
+				"vendor/golang.org/x/sys/unix/zerrors_linux.go",
+				"vendor/golang.org/x/sys/unix/ztypes_darwin_amd64.go",
+				"vendor/golang.org/x/sys/unix/ztypes_darwin_arm64.go",
+				"vendor/golang.org/x/sys/unix/ztypes_dragonfly_amd64.go",
+				"vendor/golang.org/x/sys/unix/ztypes_freebsd_386.go",
+				"vendor/golang.org/x/sys/unix/ztypes_freebsd_amd64.go",
+				"vendor/golang.org/x/sys/unix/ztypes_freebsd_arm.go",
+				"vendor/golang.org/x/sys/unix/ztypes_freebsd_arm64.go",
+				"vendor/golang.org/x/sys/unix/ztypes_netbsd_386.go",
+				"vendor/golang.org/x/sys/unix/ztypes_netbsd_amd64.go",
+				"vendor/golang.org/x/sys/unix/ztypes_netbsd_arm.go",
+				"vendor/golang.org/x/sys/unix/ztypes_netbsd_arm64.go",
+				"vendor/modules.txt",
+			},
+			added: []string{
+				"vendor/github.com/gliderlabs/ssh/go.mod",
+				"vendor/github.com/gliderlabs/ssh/go.sum",
+			},
+			removed: []string{},
+		},
+		{
+			// git 1.7.2 adds an unnecessary \x00 on merge commit
+			output: "\x00MM\x00options/locale/locale_en-US.ini\x00",
+			modified: []string{
+				"options/locale/locale_en-US.ini",
+			},
+			added:   []string{},
+			removed: []string{},
+		},
+		{
+			// git 1.7.2 adds an unnecessary \n on normal commit
+			output: "\nD\x00b\x00D\x00b b/b\x00A\x00b b/b b/b b/b\x00A\x00b b/b b/b b/b b/b\x00",
+			removed: []string{
+				"b",
+				"b b/b",
+			},
+			modified: []string{},
+			added: []string{
+				"b b/b b/b b/b",
+				"b b/b b/b b/b b/b",
+			},
+		},
+	}
+
+	for _, kase := range kases {
+		fileStatus := NewCommitFileStatus()
+		parseCommitFileStatus(fileStatus, strings.NewReader(kase.output))
+
+		assert.Equal(t, kase.added, fileStatus.Added)
+		assert.Equal(t, kase.removed, fileStatus.Removed)
+		assert.Equal(t, kase.modified, fileStatus.Modified)
+	}
+}
+
+func TestGetCommitFileStatusMerges(t *testing.T) {
+	bareRepo6 := mockRepository("repo6_merge")
+
+	commitFileStatus, err := GetCommitFileStatus(t.Context(), bareRepo6, "022f4ce6214973e018f02bf363bf8a2e3691f699")
+	assert.NoError(t, err)
+
+	expected := CommitFileStatus{
+		[]string{
+			"add_file.txt",
+		},
+		[]string{
+			"to_remove.txt",
+		},
+		[]string{
+			"to_modify.txt",
+		},
+	}
+
+	assert.Equal(t, expected.Added, commitFileStatus.Added)
+	assert.Equal(t, expected.Removed, commitFileStatus.Removed)
+	assert.Equal(t, expected.Modified, commitFileStatus.Modified)
+}
+
+func TestGetCommitFileStatusMergesSha256(t *testing.T) {
+	bareRepo6Sha256 := mockRepository("repo6_merge_sha256")
+
+	commitFileStatus, err := GetCommitFileStatus(t.Context(), bareRepo6Sha256, "d2e5609f630dd8db500f5298d05d16def282412e3e66ed68cc7d0833b29129a1")
+	assert.NoError(t, err)
+
+	expected := CommitFileStatus{
+		[]string{
+			"add_file.txt",
+		},
+		[]string{},
+		[]string{
+			"to_modify.txt",
+		},
+	}
+
+	assert.Equal(t, expected.Added, commitFileStatus.Added)
+	assert.Equal(t, expected.Removed, commitFileStatus.Removed)
+	assert.Equal(t, expected.Modified, commitFileStatus.Modified)
+
+	expected = CommitFileStatus{
+		[]string{},
+		[]string{
+			"to_remove.txt",
+		},
+		[]string{},
+	}
+
+	commitFileStatus, err = GetCommitFileStatus(t.Context(), bareRepo6Sha256, "da1ded40dc8e5b7c564171f4bf2fc8370487decfb1cb6a99ef28f3ed73d09172")
+	assert.NoError(t, err)
+
+	assert.Equal(t, expected.Added, commitFileStatus.Added)
+	assert.Equal(t, expected.Removed, commitFileStatus.Removed)
+	assert.Equal(t, expected.Modified, commitFileStatus.Modified)
+}
--- a/modules/git/commit_sha256_test.go
+++ b/modules/git/commit_sha256_test.go
@@ -15,17 +15,13 @@ import (
 )

 func TestGetFullCommitIDSha256(t *testing.T) {
-	bareRepo1Path := filepath.Join(testReposDir, "repo1_bare_sha256")
-
-	id, err := GetFullCommitID(t.Context(), bareRepo1Path, "f004f4")
+	id, err := GetFullCommitID(t.Context(), mockRepository("repo1_bare_sha256"), "f004f4")
 	assert.NoError(t, err)
 	assert.Equal(t, "f004f41359117d319dedd0eaab8c5259ee2263da839dcba33637997458627fdc", id)
 }

 func TestGetFullCommitIDErrorSha256(t *testing.T) {
-	bareRepo1Path := filepath.Join(testReposDir, "repo1_bare_sha256")
-
-	id, err := GetFullCommitID(t.Context(), bareRepo1Path, "unknown")
+	id, err := GetFullCommitID(t.Context(), mockRepository("repo1_bare_sha256"), "unknown")
 	assert.Empty(t, id)
 	if assert.Error(t, err) {
 		assert.EqualError(t, err, "object does not exist [id: unknown, rel_path: ]")
--- a/modules/git/commit_test.go
+++ b/modules/git/commit_test.go
@@ -14,17 +14,13 @@ import (
 )

 func TestGetFullCommitID(t *testing.T) {
-	bareRepo1Path := filepath.Join(testReposDir, "repo1_bare")
-
-	id, err := GetFullCommitID(t.Context(), bareRepo1Path, "8006ff9a")
+	id, err := GetFullCommitID(t.Context(), mockRepository("repo1_bare"), "8006ff9a")
 	assert.NoError(t, err)
 	assert.Equal(t, "8006ff9adbf0cb94da7dad9e537e53817f9fa5c0", id)
 }

 func TestGetFullCommitIDError(t *testing.T) {
-	bareRepo1Path := filepath.Join(testReposDir, "repo1_bare")
-
-	id, err := GetFullCommitID(t.Context(), bareRepo1Path, "unknown")
+	id, err := GetFullCommitID(t.Context(), mockRepository("repo1_bare"), "unknown")
 	assert.Empty(t, id)
 	if assert.Error(t, err) {
 		assert.EqualError(t, err, "object does not exist [id: unknown, rel_path: ]")
--- a/modules/git/compare.go
+++ b/modules/git/compare.go
@@ -0,0 +1,70 @@
+// Copyright 2025 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package git
+
+import (
+	"context"
+	"fmt"
+	"strconv"
+	"strings"
+
+	"gitea.dev/modules/git/gitcmd"
+)
+
+// DivergeObject represents commit count diverging commits
+type DivergeObject struct {
+	Ahead  int
+	Behind int
+}
+
+// GetDivergingCommits returns the number of commits a targetBranch is ahead or behind a baseBranch
+func GetDivergingCommits(ctx context.Context, repo RepositoryFacade, baseBranch, targetBranch string) (*DivergeObject, error) {
+	cmd := gitcmd.NewCommand("rev-list", "--count", "--left-right").
+		AddDynamicArguments(baseBranch + "..." + targetBranch).AddArguments("--")
+	stdout, _, err1 := cmd.WithRepo(repo).RunStdString(ctx)
+	if err1 != nil {
+		return nil, err1
+	}
+
+	left, right, found := strings.Cut(strings.Trim(stdout, "\n"), "\t")
+	if !found {
+		return nil, fmt.Errorf("git rev-list output is missing a tab: %q", stdout)
+	}
+
+	behind, err := strconv.Atoi(left)
+	if err != nil {
+		return nil, err
+	}
+	ahead, err := strconv.Atoi(right)
+	if err != nil {
+		return nil, err
+	}
+	return &DivergeObject{Ahead: ahead, Behind: behind}, nil
+}
+
+// GetCommitIDsBetweenReverse returns the last commit IDs between two commits in reverse order (from old to new) with limit.
+// If the result exceeds the limit, the old commits IDs will be ignored
+func GetCommitIDsBetweenReverse(ctx context.Context, repo RepositoryFacade, startRef, endRef, notRef string, limit int) ([]string, error) {
+	genCmd := func(reversions ...string) *gitcmd.Command {
+		cmd := gitcmd.NewCommand("rev-list", "--reverse").
+			AddArguments("-n").AddDynamicArguments(strconv.Itoa(limit)).
+			AddDynamicArguments(reversions...)
+		if notRef != "" { // --not should be kept as the last parameter of git command, otherwise the result will be wrong
+			cmd.AddOptionValues("--not", notRef)
+		}
+		return cmd
+	}
+	stdout, _, err := genCmd(startRef + ".." + endRef).WithRepo(repo).RunStdString(ctx)
+	if gitcmd.IsStderr(err, gitcmd.StderrNoMergeBase) {
+		// if the start and end are not related (no merge base), just get all commits pushed by "end ref"
+		// previously it would return the results of git rev-list before last so let's try that...
+		stdout, _, err = genCmd(endRef).WithRepo(repo).RunStdString(ctx)
+	}
+	if err != nil {
+		return nil, err
+	}
+
+	commitIDs := strings.Fields(strings.TrimSpace(stdout))
+	return commitIDs, nil
+}
--- a/modules/git/compare_test.go
+++ b/modules/git/compare_test.go
@@ -0,0 +1,138 @@
+// Copyright 2024 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package git
+
+import (
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"gitea.dev/modules/git/gitcmd"
+	"gitea.dev/modules/util"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestMergeBaseNoCommonHistory(t *testing.T) {
+	repoDir := filepath.Join(t.TempDir(), "repo.git")
+	require.NoError(t, gitcmd.NewCommand("init").AddDynamicArguments(repoDir).Run(t.Context()))
+	_, _, runErr := gitcmd.NewCommand("fast-import").WithDir(repoDir).WithStdinBytes([]byte(strings.TrimSpace(`
+commit refs/heads/branch1
+committer User <user@example.com> 1714310400 +0000
+data 12
+First commit
+M 100644 inline file1.txt
+data 12
+Hello from 1
+
+commit refs/heads/branch2
+committer User <user@example.com> 1714310400 +0000
+data 13
+Second commit
+M 100644 inline file2.txt
+data 12
+Hello from 2
+`))).RunStdString(t.Context())
+	require.NoError(t, runErr)
+	mergeBase, err := MergeBase(t.Context(), mockRepository(repoDir), "branch1", "branch2")
+	assert.Empty(t, mergeBase)
+	assert.ErrorIs(t, err, util.ErrNotExist)
+}
+
+func TestRepoGetDivergingCommits(t *testing.T) {
+	repo := mockRepository("repo1_bare")
+	do, err := GetDivergingCommits(t.Context(), repo, "master", "branch2")
+	assert.NoError(t, err)
+	assert.Equal(t, &DivergeObject{
+		Ahead:  1,
+		Behind: 5,
+	}, do)
+
+	do, err = GetDivergingCommits(t.Context(), repo, "master", "master")
+	assert.NoError(t, err)
+	assert.Equal(t, &DivergeObject{
+		Ahead:  0,
+		Behind: 0,
+	}, do)
+
+	do, err = GetDivergingCommits(t.Context(), repo, "master", "test")
+	assert.NoError(t, err)
+	assert.Equal(t, &DivergeObject{
+		Ahead:  0,
+		Behind: 2,
+	}, do)
+}
+
+func TestGetCommitIDsBetweenReverse(t *testing.T) {
+	repo := mockRepository("repo1_bare")
+
+	// tests raw commit IDs
+	commitIDs, err := GetCommitIDsBetweenReverse(t.Context(), repo,
+		"8d92fc957a4d7cfd98bc375f0b7bb189a0d6c9f2",
+		"ce064814f4a0d337b333e646ece456cd39fab612",
+		"",
+		100,
+	)
+	assert.NoError(t, err)
+	assert.Equal(t, []string{
+		"8006ff9adbf0cb94da7dad9e537e53817f9fa5c0",
+		"6fbd69e9823458e6c4a2fc5c0f6bc022b2f2acd1",
+		"37991dec2c8e592043f47155ce4808d4580f9123",
+		"feaf4ba6bc635fec442f46ddd4512416ec43c2c2",
+		"ce064814f4a0d337b333e646ece456cd39fab612",
+	}, commitIDs)
+
+	commitIDs, err = GetCommitIDsBetweenReverse(t.Context(), repo,
+		"8d92fc957a4d7cfd98bc375f0b7bb189a0d6c9f2",
+		"ce064814f4a0d337b333e646ece456cd39fab612",
+		"6fbd69e9823458e6c4a2fc5c0f6bc022b2f2acd1",
+		100,
+	)
+	assert.NoError(t, err)
+	assert.Equal(t, []string{
+		"37991dec2c8e592043f47155ce4808d4580f9123",
+		"feaf4ba6bc635fec442f46ddd4512416ec43c2c2",
+		"ce064814f4a0d337b333e646ece456cd39fab612",
+	}, commitIDs)
+
+	commitIDs, err = GetCommitIDsBetweenReverse(t.Context(), repo,
+		"8d92fc957a4d7cfd98bc375f0b7bb189a0d6c9f2",
+		"ce064814f4a0d337b333e646ece456cd39fab612",
+		"",
+		3,
+	)
+	assert.NoError(t, err)
+	assert.Equal(t, []string{
+		"37991dec2c8e592043f47155ce4808d4580f9123",
+		"feaf4ba6bc635fec442f46ddd4512416ec43c2c2",
+		"ce064814f4a0d337b333e646ece456cd39fab612",
+	}, commitIDs)
+
+	// test branch names instead of raw commit IDs.
+	commitIDs, err = GetCommitIDsBetweenReverse(t.Context(), repo,
+		"test",
+		"master",
+		"",
+		100,
+	)
+	assert.NoError(t, err)
+	assert.Equal(t, []string{
+		"feaf4ba6bc635fec442f46ddd4512416ec43c2c2",
+		"ce064814f4a0d337b333e646ece456cd39fab612",
+	}, commitIDs)
+
+	// add notref to exclude test
+	commitIDs, err = GetCommitIDsBetweenReverse(t.Context(), repo,
+		"test",
+		"master",
+		"test",
+		100,
+	)
+	assert.NoError(t, err)
+	assert.Equal(t, []string{
+		"feaf4ba6bc635fec442f46ddd4512416ec43c2c2",
+		"ce064814f4a0d337b333e646ece456cd39fab612",
+	}, commitIDs)
+}
--- a/modules/git/config_managed.go
+++ b/modules/git/config_managed.go
@@ -0,0 +1,30 @@
+// Copyright 2025 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package git
+
+import (
+	"context"
+
+	"gitea.dev/modules/git/gitcmd"
+)
+
+// ManagedConfigAdd add a git configuration key to a specific value for the given repository.
+func ManagedConfigAdd(ctx context.Context, repo RepositoryFacade, key, value string) error {
+	return LockConfigAndDo(ctx, repo, func(ctx context.Context) error {
+		_, _, err := gitcmd.NewCommand("config", "--add").
+			AddDynamicArguments(key, value).WithRepo(repo).RunStdString(ctx)
+		return err
+	})
+}
+
+// ManagedConfigSet updates a git configuration key to a specific value for the given repository.
+// If the key does not exist, it will be created.
+// If the key exists, it will be updated to the new value.
+func ManagedConfigSet(ctx context.Context, repo RepositoryFacade, key, value string) error {
+	return LockConfigAndDo(ctx, repo, func(ctx context.Context) error {
+		_, _, err := gitcmd.NewCommand("config").
+			AddDynamicArguments(key, value).WithRepo(repo).RunStdString(ctx)
+		return err
+	})
+}
--- a/modules/git/diff.go
+++ b/modules/git/diff.go
@@ -65,7 +65,7 @@ func getRepoRawDiffForFileCmd(ctx context.Context, repo *Repository, startCommit
 		files = append(files, file)
 	}

-	cmd := gitcmd.NewCommand().WithDir(repo.Path)
+	cmd := gitcmd.NewCommand().WithRepo(repo)
 	switch diffType {
 	case RawDiffNormal:
 		if len(startCommit) != 0 {
@@ -310,7 +310,7 @@ func GetAffectedFiles(ctx context.Context, repo *Repository, branchName, oldComm
 	cmd := gitcmd.NewCommand("diff", "--name-only").AddDynamicArguments(oldCommitID, newCommitID)
 	stdoutReader, stdoutReaderClose := cmd.MakeStdoutPipe()
 	defer stdoutReaderClose()
-	err := cmd.WithEnv(env).WithDir(repo.Path).
+	err := cmd.WithEnv(env).WithRepo(repo).
 		WithPipelineFunc(func(ctx gitcmd.Context) error {
 			// Now scan the output from the command
 			scanner := bufio.NewScanner(stdoutReader)
--- a/modules/git/diff2.go
+++ b/modules/git/diff2.go
@@ -0,0 +1,71 @@
+// Copyright 2025 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package git
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"regexp"
+	"strconv"
+
+	"gitea.dev/modules/git/gitcmd"
+)
+
+// GetDiffShortStatByCmdArgs counts number of changed files, number of additions and deletions
+// TODO: it can be merged with another "GetDiffShortStat" in the future
+func GetDiffShortStatByCmdArgs(ctx context.Context, repo RepositoryFacade, trustedArgs gitcmd.TrustedCmdArgs, dynamicArgs ...string) (numFiles, totalAdditions, totalDeletions int, err error) {
+	// Now if we call:
+	// $ git diff --shortstat 1ebb35b98889ff77299f24d82da426b434b0cca0...788b8b1440462d477f45b0088875
+	// we get:
+	// " 9902 files changed, 2034198 insertions(+), 298800 deletions(-)\n"
+	cmd := gitcmd.NewCommand("diff", "--shortstat").AddArguments(trustedArgs...).AddDynamicArguments(dynamicArgs...)
+	stdout, _, err := cmd.WithRepo(repo).RunStdString(ctx)
+	if err != nil {
+		return 0, 0, 0, err
+	}
+
+	return parseDiffStat(stdout)
+}
+
+var shortStatFormat = regexp.MustCompile(
+	`\s*(\d+) files? changed(?:, (\d+) insertions?\(\+\))?(?:, (\d+) deletions?\(-\))?`)
+
+func parseDiffStat(stdout string) (numFiles, totalAdditions, totalDeletions int, err error) {
+	if len(stdout) == 0 || stdout == "\n" {
+		return 0, 0, 0, nil
+	}
+	groups := shortStatFormat.FindStringSubmatch(stdout)
+	if len(groups) != 4 {
+		return 0, 0, 0, fmt.Errorf("unable to parse shortstat: %s groups: %s", stdout, groups)
+	}
+
+	numFiles, err = strconv.Atoi(groups[1])
+	if err != nil {
+		return 0, 0, 0, fmt.Errorf("unable to parse shortstat: %s. Error parsing NumFiles %w", stdout, err)
+	}
+
+	if len(groups[2]) != 0 {
+		totalAdditions, err = strconv.Atoi(groups[2])
+		if err != nil {
+			return 0, 0, 0, fmt.Errorf("unable to parse shortstat: %s. Error parsing NumAdditions %w", stdout, err)
+		}
+	}
+
+	if len(groups[3]) != 0 {
+		totalDeletions, err = strconv.Atoi(groups[3])
+		if err != nil {
+			return 0, 0, 0, fmt.Errorf("unable to parse shortstat: %s. Error parsing NumDeletions %w", stdout, err)
+		}
+	}
+	return numFiles, totalAdditions, totalDeletions, err
+}
+
+// GetReverseRawDiff dumps the reverse diff results of repository in given commit ID to io.Writer.
+func GetReverseRawDiff(ctx context.Context, repo RepositoryFacade, commitID string, writer io.Writer) error {
+	return gitcmd.NewCommand("show", "--pretty=format:revert %H%n", "-R").
+		AddDynamicArguments(commitID).
+		WithStdoutCopy(writer).
+		WithRepo(repo).RunWithStderr(ctx)
+}
--- a/modules/git/fetch.go
+++ b/modules/git/fetch.go
@@ -0,0 +1,28 @@
+// Copyright 2025 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package git
+
+import (
+	"context"
+
+	"gitea.dev/modules/git/gitcmd"
+)
+
+// FetchRemoteCommit fetches a specific commit and its related objects from a remote
+// repository into the managed repository.
+//
+// If no reference (branch, tag, or other ref) points to the fetched commit, it will
+// be treated as unreachable and cleaned up by `git gc` after the default prune
+// expiration period (2 weeks). Ref: https://www.kernel.org/pub/software/scm/git/docs/git-gc.html
+//
+// This behavior is sufficient for temporary operations, such as determining the
+// merge base between commits.
+func FetchRemoteCommit(ctx context.Context, repo, remoteRepo RepositoryFacade, commitID string) error {
+	return LockWriteAndDo(ctx, repo, func(ctx context.Context) error {
+		return gitcmd.NewCommand("fetch", "--no-tags").
+			AddDynamicArguments(gitcmd.RepoLocalPath(remoteRepo)).
+			AddDynamicArguments(commitID).
+			WithRepo(repo).Run(ctx)
+	})
+}
--- a/modules/git/fsck.go
+++ b/modules/git/fsck.go
@@ -0,0 +1,16 @@
+// Copyright 2024 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package git
+
+import (
+	"context"
+	"time"
+
+	"gitea.dev/modules/git/gitcmd"
+)
+
+// Fsck verifies the connectivity and validity of the objects in the database
+func Fsck(ctx context.Context, repo RepositoryFacade, timeout time.Duration, args gitcmd.TrustedCmdArgs) error {
+	return gitcmd.NewCommand("fsck").AddArguments(args...).WithTimeout(timeout).WithRepo(repo).Run(ctx)
+}
--- a/modules/git/git_test.go
+++ b/modules/git/git_test.go
@@ -10,12 +10,6 @@ import (
 	"github.com/stretchr/testify/assert"
 )

-const testReposDir = "tests/repos/"
-
-func TestMain(m *testing.M) {
-	RunGitTests(m)
-}
-
 func TestParseGitVersion(t *testing.T) {
 	v, err := parseGitVersionLine("git version 2.29.3")
 	assert.NoError(t, err)
--- a/modules/git/gitrepo.go
+++ b/modules/git/gitrepo.go
@@ -0,0 +1,51 @@
+// Copyright 2024 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package git
+
+import (
+	"context"
+	"io"
+
+	"gitea.dev/modules/git/gitcmd"
+	"gitea.dev/modules/reqctx"
+	"gitea.dev/modules/util"
+)
+
+// contextKey is a value for use with context.WithValue.
+type contextKey struct {
+	key string
+}
+
+// RepositoryFromContextOrOpen attempts to get the repository from the context or just opens it
+// The caller must call Closer.Close()
+func RepositoryFromContextOrOpen(ctx context.Context, repo RepositoryFacade) (*Repository, io.Closer, error) {
+	reqCtx := reqctx.FromContext(ctx)
+	if reqCtx != nil {
+		gitRepo, err := RepositoryFromRequestContextOrOpen(reqCtx, repo)
+		return gitRepo, util.NopCloser{}, err
+	}
+	gitRepo, err := OpenRepository(repo)
+	return gitRepo, gitRepo, err
+}
+
+// RepositoryFromRequestContextOrOpen opens the repository at the given relative path in the provided request context.
+// Caller shouldn't close the git repo manually, the git repo will be automatically closed when the request context is done.
+func RepositoryFromRequestContextOrOpen(ctx reqctx.RequestContext, repo RepositoryFacade) (*Repository, error) {
+	ck := contextKey{key: repo.GitRepoLocation()}
+	if gitRepo, ok := ctx.Value(ck).(*Repository); ok {
+		return gitRepo, nil
+	}
+	gitRepo, err := OpenRepository(repo)
+	if err != nil {
+		return nil, err
+	}
+	ctx.AddCloser(gitRepo)
+	ctx.SetContextValue(ck, gitRepo)
+	return gitRepo, nil
+}
+
+func UpdateServerInfo(ctx context.Context, repo RepositoryFacade) error {
+	_, _, err := gitcmd.NewCommand("update-server-info").WithRepo(repo).RunStdBytes(ctx)
+	return err
+}
--- a/modules/git/grep.go
+++ b/modules/git/grep.go
@@ -80,7 +80,7 @@ func GrepSearch(ctx context.Context, repo *Repository, search string, opts GrepO

 	stdoutReader, stdoutReaderClose := cmd.MakeStdoutPipe()
 	defer stdoutReaderClose()
-	err := cmd.WithDir(repo.Path).
+	err := cmd.WithRepo(repo).
 		WithTimeout(grepSearchTimeout).
 		WithPipelineFunc(func(ctx gitcmd.Context) error {
 			isInBlock := false
--- a/modules/git/grep_test.go
+++ b/modules/git/grep_test.go
@@ -7,6 +7,8 @@ import (
 	"path/filepath"
 	"testing"

+	"gitea.dev/modules/git/gitcmd"
+
 	"github.com/stretchr/testify/assert"
 )

@@ -74,7 +76,8 @@ func TestGrepSearch(t *testing.T) {
 	assert.NoError(t, err)
 	assert.Empty(t, res)

-	res, err = GrepSearch(t.Context(), &Repository{RepositoryBase: RepositoryBase{Path: "no-such-git-repo"}}, "no-such-content", GrepOptions{})
+	nonExistingRepo := &Repository{RepositoryBase: RepositoryBase{Path: "no-such-git-repo", repoFacade: gitcmd.RepositoryUnmanaged("no-such-git-repo")}}
+	res, err = GrepSearch(t.Context(), nonExistingRepo, "no-such-content", GrepOptions{})
 	assert.Error(t, err)
 	assert.Empty(t, res)
 }
--- a/modules/git/hooks.go
+++ b/modules/git/hooks.go
@@ -0,0 +1,241 @@
+// Copyright 2020 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package git
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"path/filepath"
+	"runtime"
+
+	"gitea.dev/modules/git/gitcmd"
+	"gitea.dev/modules/setting"
+	"gitea.dev/modules/util"
+)
+
+func getHookTemplates() (hookNames, hookTpls, giteaHookTpls []string) {
+	hookNames = []string{"pre-receive", "update", "post-receive"}
+	hookTpls = []string{
+		// for pre-receive
+		fmt.Sprintf(`#!/usr/bin/env %s
+# AUTO GENERATED BY GITEA, DO NOT MODIFY
+data=$(cat)
+exitcodes=""
+hookname=$(basename $0)
+GIT_DIR=${GIT_DIR:-$(dirname $0)/..}
+
+for hook in ${GIT_DIR}/hooks/${hookname}.d/*; do
+  test -x "${hook}" && test -f "${hook}" || continue
+  echo "${data}" | "${hook}"
+  exitcodes="${exitcodes} $?"
+done
+
+for i in ${exitcodes}; do
+  [ ${i} -eq 0 ] || exit ${i}
+done
+`, setting.ScriptType),
+
+		// for update
+		fmt.Sprintf(`#!/usr/bin/env %s
+# AUTO GENERATED BY GITEA, DO NOT MODIFY
+exitcodes=""
+hookname=$(basename $0)
+GIT_DIR=${GIT_DIR:-$(dirname $0/..)}
+
+for hook in ${GIT_DIR}/hooks/${hookname}.d/*; do
+  test -x "${hook}" && test -f "${hook}" || continue
+  "${hook}" $1 $2 $3
+  exitcodes="${exitcodes} $?"
+done
+
+for i in ${exitcodes}; do
+  [ ${i} -eq 0 ] || exit ${i}
+done
+`, setting.ScriptType),
+
+		// for post-receive
+		fmt.Sprintf(`#!/usr/bin/env %s
+# AUTO GENERATED BY GITEA, DO NOT MODIFY
+data=$(cat)
+exitcodes=""
+hookname=$(basename $0)
+GIT_DIR=${GIT_DIR:-$(dirname $0)/..}
+
+for hook in ${GIT_DIR}/hooks/${hookname}.d/*; do
+  test -x "${hook}" && test -f "${hook}" || continue
+  echo "${data}" | "${hook}"
+  exitcodes="${exitcodes} $?"
+done
+
+for i in ${exitcodes}; do
+  [ ${i} -eq 0 ] || exit ${i}
+done
+`, setting.ScriptType),
+	}
+
+	giteaHookTpls = []string{
+		// for pre-receive
+		fmt.Sprintf(`#!/usr/bin/env %s
+# AUTO GENERATED BY GITEA, DO NOT MODIFY
+%s hook --config=%s pre-receive
+`, setting.ScriptType, util.ShellEscape(setting.AppPath), util.ShellEscape(setting.CustomConf)),
+
+		// for update
+		fmt.Sprintf(`#!/usr/bin/env %s
+# AUTO GENERATED BY GITEA, DO NOT MODIFY
+%s hook --config=%s update $1 $2 $3
+`, setting.ScriptType, util.ShellEscape(setting.AppPath), util.ShellEscape(setting.CustomConf)),
+
+		// for post-receive
+		fmt.Sprintf(`#!/usr/bin/env %s
+# AUTO GENERATED BY GITEA, DO NOT MODIFY
+%s hook --config=%s post-receive
+`, setting.ScriptType, util.ShellEscape(setting.AppPath), util.ShellEscape(setting.CustomConf)),
+	}
+
+	// although only new git (>=2.29) supports proc-receive, it's still good to create its hook, in case the user upgrades git
+	hookNames = append(hookNames, "proc-receive")
+	hookTpls = append(hookTpls,
+		fmt.Sprintf(`#!/usr/bin/env %s
+# AUTO GENERATED BY GITEA, DO NOT MODIFY
+%s hook --config=%s proc-receive
+`, setting.ScriptType, util.ShellEscape(setting.AppPath), util.ShellEscape(setting.CustomConf)))
+	giteaHookTpls = append(giteaHookTpls, "")
+
+	return hookNames, hookTpls, giteaHookTpls
+}
+
+// CreateDelegateHooks creates all the hooks scripts for the repo
+func CreateDelegateHooks(_ context.Context, repo RepositoryFacade) (err error) {
+	return createDelegateHooks(filepath.Join(gitcmd.RepoLocalPath(repo), "hooks"))
+}
+
+func createDelegateHooks(hookDir string) (err error) {
+	hookNames, hookTpls, giteaHookTpls := getHookTemplates()
+
+	for i, hookName := range hookNames {
+		oldHookPath := filepath.Join(hookDir, hookName)
+		newHookPath := filepath.Join(hookDir, hookName+".d", "gitea")
+
+		if err := os.MkdirAll(filepath.Join(hookDir, hookName+".d"), os.ModePerm); err != nil {
+			return fmt.Errorf("create hooks dir '%s': %w", filepath.Join(hookDir, hookName+".d"), err)
+		}
+
+		// WARNING: This will override all old server-side hooks
+		if err = util.Remove(oldHookPath); err != nil && !os.IsNotExist(err) {
+			return fmt.Errorf("unable to pre-remove old hook file '%s' prior to rewriting: %w ", oldHookPath, err)
+		}
+		if err = os.WriteFile(oldHookPath, []byte(hookTpls[i]), 0o777); err != nil {
+			return fmt.Errorf("write old hook file '%s': %w", oldHookPath, err)
+		}
+
+		if err = ensureExecutable(oldHookPath); err != nil {
+			return fmt.Errorf("Unable to set %s executable. Error %w", oldHookPath, err)
+		}
+
+		if err = util.Remove(newHookPath); err != nil && !os.IsNotExist(err) {
+			return fmt.Errorf("unable to pre-remove new hook file '%s' prior to rewriting: %w", newHookPath, err)
+		}
+		if err = os.WriteFile(newHookPath, []byte(giteaHookTpls[i]), 0o777); err != nil {
+			return fmt.Errorf("write new hook file '%s': %w", newHookPath, err)
+		}
+
+		if err = ensureExecutable(newHookPath); err != nil {
+			return fmt.Errorf("Unable to set %s executable. Error %w", oldHookPath, err)
+		}
+	}
+
+	return nil
+}
+
+func checkExecutable(filename string) bool {
+	// windows has no concept of a executable bit
+	if runtime.GOOS == "windows" {
+		return true
+	}
+	fileInfo, err := os.Stat(filename)
+	if err != nil {
+		return false
+	}
+	return (fileInfo.Mode() & 0o100) > 0
+}
+
+func ensureExecutable(filename string) error {
+	fileInfo, err := os.Stat(filename)
+	if err != nil {
+		return err
+	}
+	if (fileInfo.Mode() & 0o100) > 0 {
+		return nil
+	}
+	mode := fileInfo.Mode() | 0o100
+	return os.Chmod(filename, mode)
+}
+
+// CheckDelegateHooks checks the hooks scripts for the repo
+func CheckDelegateHooks(_ context.Context, repo RepositoryFacade) ([]string, error) {
+	return checkDelegateHooks(filepath.Join(gitcmd.RepoLocalPath(repo), "hooks"))
+}
+
+func checkDelegateHooks(hookDir string) ([]string, error) {
+	hookNames, hookTpls, giteaHookTpls := getHookTemplates()
+
+	results := make([]string, 0, 10)
+
+	for i, hookName := range hookNames {
+		oldHookPath := filepath.Join(hookDir, hookName)
+		newHookPath := filepath.Join(hookDir, hookName+".d", "gitea")
+
+		cont := false
+		isExist, err := util.IsExist(oldHookPath)
+		if err != nil {
+			results = append(results, fmt.Sprintf("unable to check if %s exists. Error: %v", oldHookPath, err))
+		}
+		if err == nil && !isExist {
+			results = append(results, fmt.Sprintf("old hook file %s does not exist", oldHookPath))
+			cont = true
+		}
+		isExist, err = util.IsExist(oldHookPath + ".d")
+		if err != nil {
+			results = append(results, fmt.Sprintf("unable to check if %s exists. Error: %v", oldHookPath+".d", err))
+		}
+		if err == nil && !isExist {
+			results = append(results, fmt.Sprintf("hooks directory %s does not exist", oldHookPath+".d"))
+			cont = true
+		}
+		isExist, err = util.IsExist(newHookPath)
+		if err != nil {
+			results = append(results, fmt.Sprintf("unable to check if %s exists. Error: %v", newHookPath, err))
+		}
+		if err == nil && !isExist {
+			results = append(results, fmt.Sprintf("new hook file %s does not exist", newHookPath))
+			cont = true
+		}
+		if cont {
+			continue
+		}
+		contents, err := os.ReadFile(oldHookPath)
+		if err != nil {
+			return results, err
+		}
+		if string(contents) != hookTpls[i] {
+			results = append(results, fmt.Sprintf("old hook file %s is out of date", oldHookPath))
+		}
+		if !checkExecutable(oldHookPath) {
+			results = append(results, fmt.Sprintf("old hook file %s is not executable", oldHookPath))
+		}
+		contents, err = os.ReadFile(newHookPath)
+		if err != nil {
+			return results, err
+		}
+		if string(contents) != giteaHookTpls[i] {
+			results = append(results, fmt.Sprintf("new hook file %s is out of date", newHookPath))
+		}
+		if !checkExecutable(newHookPath) {
+			results = append(results, fmt.Sprintf("new hook file %s is not executable", newHookPath))
+		}
+	}
+	return results, nil
+}
--- a/modules/git/languagestats/language_stats_nogogit.go
+++ b/modules/git/languagestats/language_stats_nogogit.go
@@ -1,8 +1,6 @@
 // Copyright 2020 The Gitea Authors. All rights reserved.
 // SPDX-License-Identifier: MIT

-//go:build !gogit
-
 package languagestats

 import (
--- a/modules/git/languagestats/language_stats_gogit.go
+++ b/modules/git/languagestats/language_stats_gogit.go
@@ -1,182 +0,0 @@
-// Copyright 2020 The Gitea Authors. All rights reserved.
-// SPDX-License-Identifier: MIT
-
-//go:build gogit
-
-package languagestats
-
-import (
-	"bytes"
-	"context"
-	"io"
-
-	"gitea.dev/modules/analyze"
-	git_module "gitea.dev/modules/git"
-	"gitea.dev/modules/git/attribute"
-	"gitea.dev/modules/optional"
-
-	"github.com/go-enry/go-enry/v2"
-	"github.com/go-git/go-git/v5"
-	"github.com/go-git/go-git/v5/plumbing"
-	"github.com/go-git/go-git/v5/plumbing/object"
-)
-
-// GetLanguageStats calculates language stats for git repository at specified commit
-func GetLanguageStats(ctx context.Context, repo *git_module.Repository, commitID string) (map[string]int64, error) {
-	r, err := git.PlainOpen(repo.Path)
-	if err != nil {
-		return nil, err
-	}
-
-	rev, err := r.ResolveRevision(plumbing.Revision(commitID))
-	if err != nil {
-		return nil, err
-	}
-
-	commit, err := r.CommitObject(*rev)
-	if err != nil {
-		return nil, err
-	}
-
-	tree, err := commit.Tree()
-	if err != nil {
-		return nil, err
-	}
-
-	checker, err := attribute.NewBatchChecker(ctx, repo, commitID, attribute.LinguistAttributes)
-	if err != nil {
-		return nil, err
-	}
-	defer checker.Close()
-
-	// sizes contains the current calculated size of all files by language
-	sizes := make(map[string]int64)
-	// by default we will only count the sizes of programming languages or markup languages
-	// unless they are explicitly set using linguist-language
-	includedLanguage := map[string]bool{}
-	// or if there's only one language in the repository
-	firstExcludedLanguage := ""
-	firstExcludedLanguageSize := int64(0)
-
-	err = tree.Files().ForEach(func(f *object.File) error {
-		if f.Size == 0 {
-			return nil
-		}
-
-		isVendored := optional.None[bool]()
-		isGenerated := optional.None[bool]()
-		isDocumentation := optional.None[bool]()
-		isDetectable := optional.None[bool]()
-
-		attrs, err := checker.CheckPath(f.Name)
-		if err == nil {
-			isVendored = attrs.GetVendored()
-			if isVendored.ValueOrDefault(false) {
-				return nil
-			}
-
-			isGenerated = attrs.GetGenerated()
-			if isGenerated.ValueOrDefault(false) {
-				return nil
-			}
-
-			isDocumentation = attrs.GetDocumentation()
-			if isDocumentation.ValueOrDefault(false) {
-				return nil
-			}
-
-			isDetectable = attrs.GetDetectable()
-			if !isDetectable.ValueOrDefault(true) {
-				return nil
-			}
-
-			hasLanguage := attrs.GetLanguage()
-			if hasLanguage.Value() != "" {
-				language := hasLanguage.Value()
-
-				// group languages, such as Pug -> HTML; SCSS -> CSS
-				group := enry.GetLanguageGroup(language)
-				if len(group) != 0 {
-					language = group
-				}
-
-				// this language will always be added to the size
-				sizes[language] += f.Size
-				return nil
-			}
-		}
-
-		if (!isVendored.Has() && analyze.IsVendor(f.Name)) ||
-			enry.IsDotFile(f.Name) ||
-			(!isDocumentation.Has() && enry.IsDocumentation(f.Name)) ||
-			(!isDetectable.Has() && enry.IsConfiguration(f.Name)) {
-			return nil
-		}
-
-		// If content can not be read or file is too big just do detection by filename
-		var content []byte
-		if f.Size <= bigFileSize {
-			content, _ = readFile(f, fileSizeLimit)
-		}
-		if !isGenerated.Has() && enry.IsGenerated(f.Name, content) {
-			return nil
-		}
-
-		language := analyze.GetCodeLanguage(f.Name, content)
-		if language == enry.OtherLanguage || language == "" {
-			return nil
-		}
-
-		// group languages, such as Pug -> HTML; SCSS -> CSS
-		group := enry.GetLanguageGroup(language)
-		if group != "" {
-			language = group
-		}
-
-		included, checked := includedLanguage[language]
-		if !checked {
-			langtype := enry.GetLanguageType(language)
-			included = langtype == enry.Programming || langtype == enry.Markup
-			includedLanguage[language] = included
-		}
-		if included || isDetectable.ValueOrDefault(false) {
-			sizes[language] += f.Size
-		} else if len(sizes) == 0 && (firstExcludedLanguage == "" || firstExcludedLanguage == language) {
-			firstExcludedLanguage = language
-			firstExcludedLanguageSize += f.Size
-		}
-
-		return nil
-	})
-	if err != nil {
-		return nil, err
-	}
-
-	// If there are no included languages add the first excluded language
-	if len(sizes) == 0 && firstExcludedLanguage != "" {
-		sizes[firstExcludedLanguage] = firstExcludedLanguageSize
-	}
-
-	return mergeLanguageStats(sizes), nil
-}
-
-func readFile(f *object.File, limit int64) ([]byte, error) {
-	r, err := f.Reader()
-	if err != nil {
-		return nil, err
-	}
-	defer r.Close()
-
-	if limit <= 0 {
-		return io.ReadAll(r)
-	}
-
-	size := f.Size
-	if limit > 0 && size > limit {
-		size = limit
-	}
-	buf := bytes.NewBuffer(nil)
-	buf.Grow(int(size))
-	_, err = io.Copy(buf, io.LimitReader(r, limit))
-	return buf.Bytes(), err
-}
--- a/modules/git/languagestats/language_stats_test.go
+++ b/modules/git/languagestats/language_stats_test.go
@@ -1,8 +1,6 @@
 // Copyright 2020 The Gitea Authors. All rights reserved.
 // SPDX-License-Identifier: MIT

-//go:build !gogit
-
 package languagestats

 import (
--- a/modules/git/localfs.go
+++ b/modules/git/localfs.go
@@ -0,0 +1,71 @@
+// Copyright 2026 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package git
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"io/fs"
+	"os"
+	"path/filepath"
+
+	"gitea.dev/modules/git/gitcmd"
+	"gitea.dev/modules/util"
+)
+
+// IsRepositoryExist returns true if the repository directory exists in the disk
+func IsRepositoryExist(ctx context.Context, repo RepositoryFacade) (bool, error) {
+	return util.IsExist(gitcmd.RepoLocalPath(repo))
+}
+
+// DeleteRepository deletes the repository directory from the disk, it will return
+// nil if the repository does not exist.
+func DeleteRepository(ctx context.Context, repo RepositoryFacade) error {
+	return util.RemoveAll(gitcmd.RepoLocalPath(repo))
+}
+
+// RenameRepository renames a repository's name on disk
+func RenameRepository(ctx context.Context, repo, newRepo RepositoryFacade) error {
+	dstDir := gitcmd.RepoLocalPath(newRepo)
+	if err := os.MkdirAll(filepath.Dir(dstDir), os.ModePerm); err != nil {
+		return fmt.Errorf("Failed to create dir %s: %w", filepath.Dir(dstDir), err)
+	}
+
+	if err := util.Rename(gitcmd.RepoLocalPath(repo), dstDir); err != nil {
+		return fmt.Errorf("rename repository directory: %w", err)
+	}
+	return nil
+}
+
+func InitRepository(ctx context.Context, repo RepositoryFacade, objectFormatName string) error {
+	return InitRepositoryLocal(ctx, gitcmd.RepoLocalPath(repo), true, objectFormatName)
+}
+
+func GetRepoFS(repo RepositoryFacade) fs.FS {
+	return os.DirFS(gitcmd.RepoLocalPath(repo))
+}
+
+func IsRepoFileExist(ctx context.Context, repo RepositoryFacade, relativeFilePath string) (bool, error) {
+	absoluteFilePath := filepath.Join(gitcmd.RepoLocalPath(repo), relativeFilePath)
+	return util.IsExist(absoluteFilePath)
+}
+
+func IsRepoDirExist(ctx context.Context, repo RepositoryFacade, relativeDirPath string) (bool, error) {
+	absoluteDirPath := filepath.Join(gitcmd.RepoLocalPath(repo), relativeDirPath)
+	return util.IsDir(absoluteDirPath)
+}
+
+func RemoveRepoFileOrDir(ctx context.Context, repo RepositoryFacade, relativeFileOrDirPath string) error {
+	absoluteFilePath := filepath.Join(gitcmd.RepoLocalPath(repo), relativeFileOrDirPath)
+	return util.Remove(absoluteFilePath)
+}
+
+func CreateRepoFile(ctx context.Context, repo RepositoryFacade, relativeFilePath string) (io.WriteCloser, error) {
+	absoluteFilePath := filepath.Join(gitcmd.RepoLocalPath(repo), relativeFilePath)
+	if err := os.MkdirAll(filepath.Dir(absoluteFilePath), os.ModePerm); err != nil {
+		return nil, err
+	}
+	return os.Create(absoluteFilePath)
+}
--- a/modules/git/main_test.go
+++ b/modules/git/main_test.go
@@ -0,0 +1,25 @@
+// Copyright 2025 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package git
+
+import (
+	"path/filepath"
+	"testing"
+
+	"gitea.dev/modules/git/gitcmd"
+)
+
+const testReposDir = "tests/repos/"
+
+func mockRepository(repoPath string) gitcmd.RepositoryFacade {
+	if !filepath.IsAbs(repoPath) {
+		// resolve repository path relative to the unit test fixture directory
+		repoPath, _ = filepath.Abs(filepath.Join(testReposDir, repoPath))
+	}
+	return gitcmd.RepositoryUnmanaged(repoPath)
+}
+
+func TestMain(m *testing.M) {
+	RunGitTests(m)
+}
--- a/modules/git/merge.go
+++ b/modules/git/merge.go
@@ -0,0 +1,26 @@
+// Copyright 2025 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package git
+
+import (
+	"context"
+	"fmt"
+	"strings"
+
+	"gitea.dev/modules/git/gitcmd"
+	"gitea.dev/modules/util"
+)
+
+// MergeBase checks and returns merge base of two commits.
+func MergeBase(ctx context.Context, repo RepositoryFacade, baseCommitID, headCommitID string) (string, error) {
+	mergeBase, stderr, err := gitcmd.NewCommand("merge-base").
+		AddDashesAndList(baseCommitID, headCommitID).WithRepo(repo).RunStdString(ctx)
+	if err != nil {
+		if gitcmd.IsErrorExitCode(err, 1) && strings.TrimSpace(stderr) == "" {
+			return "", util.NewNotExistErrorf("merge-base for %s and %s doesn't exist", baseCommitID, headCommitID)
+		}
+		return "", fmt.Errorf("get merge-base of %s and %s failed: %w", baseCommitID, headCommitID, err)
+	}
+	return strings.TrimSpace(mergeBase), nil
+}
--- a/modules/git/merge_tree.go
+++ b/modules/git/merge_tree.go
@@ -0,0 +1,59 @@
+// Copyright 2026 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package git
+
+import (
+	"bufio"
+	"context"
+	"fmt"
+
+	"gitea.dev/modules/git/gitcmd"
+	"gitea.dev/modules/util"
+)
+
+const MaxConflictedDetectFiles = 10
+
+// MergeTree performs a merge between two commits (baseRef and headRef) with an optional merge base.
+// It returns the resulting tree hash, a list of conflicted files (if any), and an error if the operation fails.
+// If there are no conflicts, the list of conflicted files will be nil.
+func MergeTree(ctx context.Context, repo RepositoryFacade, baseRef, headRef, mergeBase string) (treeID string, isErrHasConflicts bool, conflictFiles []string, _ error) {
+	cmd := gitcmd.NewCommand("merge-tree", "--write-tree", "-z", "--name-only", "--no-messages").
+		AddOptionFormat("--merge-base=%s", mergeBase).
+		AddDynamicArguments(baseRef, headRef)
+
+	stdout, stdoutClose := cmd.MakeStdoutPipe()
+	defer stdoutClose()
+	cmd.WithPipelineFunc(func(ctx gitcmd.Context) error {
+		// https://git-scm.com/docs/git-merge-tree/2.38.0#OUTPUT
+		// For a conflicted merge, the output is:
+		// <OID of toplevel tree>NUL
+		// <Conflicted file name 1>NUL
+		// <Conflicted file name 2>NUL
+		// ...
+		scanner := bufio.NewScanner(stdout)
+		scanner.Split(util.BufioScannerSplit(0))
+		for scanner.Scan() {
+			line := scanner.Text()
+			if treeID == "" { // first line is tree ID
+				treeID = line
+				continue
+			}
+			conflictFiles = append(conflictFiles, line)
+			if len(conflictFiles) >= MaxConflictedDetectFiles {
+				break
+			}
+		}
+		return scanner.Err()
+	})
+
+	err := cmd.WithRepo(repo).RunWithStderr(ctx)
+	// For a successful, non-conflicted merge, the exit status is 0. When the merge has conflicts, the exit status is 1.
+	// A merge can have conflicts without having individual files conflict
+	// https://git-scm.com/docs/git-merge-tree/2.38.0#_mistakes_to_avoid
+	isErrHasConflicts = gitcmd.IsErrorExitCode(err, 1)
+	if err == nil || isErrHasConflicts {
+		return treeID, isErrHasConflicts, conflictFiles, nil
+	}
+	return "", false, nil, fmt.Errorf("run merge-tree failed: %w", err)
+}
--- a/modules/git/merge_tree_test.go
+++ b/modules/git/merge_tree_test.go
@@ -0,0 +1,82 @@
+// Copyright 2026 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package git
+
+import (
+	"path/filepath"
+	"testing"
+
+	"gitea.dev/modules/git/gitcmd"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func prepareRepoDirRenameConflict(t *testing.T) string {
+	repoDir := filepath.Join(t.TempDir(), "repo-dir-rename-conflict.git")
+	require.NoError(t, gitcmd.NewCommand("init", "--bare").AddDynamicArguments(repoDir).Run(t.Context()))
+	stdin := `blob
+mark :1
+data 2
+b
+
+blob
+mark :2
+data 2
+c
+
+reset refs/heads/master
+commit refs/heads/master
+mark :3
+author test <test@example.com> 1769202331 -0800
+committer test <test@example.com> 1769202331 -0800
+data 2
+O
+M 100644 :1 z/b
+M 100644 :2 z/c
+
+commit refs/heads/split
+mark :4
+author test <test@example.com> 1769202336 -0800
+committer test <test@example.com> 1769202336 -0800
+data 2
+A
+from :3
+M 100644 :2 w/c
+M 100644 :1 y/b
+D z/b
+D z/c
+
+blob
+mark :5
+data 2
+d
+
+commit refs/heads/add
+mark :6
+author test <test@example.com> 1769202342 -0800
+committer test <test@example.com> 1769202342 -0800
+data 2
+B
+from :3
+M 100644 :5 z/d
+`
+	require.NoError(t, gitcmd.NewCommand("fast-import").WithDir(repoDir).WithStdinBytes([]byte(stdin)).Run(t.Context()))
+	return repoDir
+}
+
+func TestMergeTreeDirectoryRenameConflictWithoutFiles(t *testing.T) {
+	repoDir := prepareRepoDirRenameConflict(t)
+	require.DirExists(t, repoDir)
+	repo := mockRepository(repoDir)
+
+	mergeBase, err := MergeBase(t.Context(), repo, "add", "split")
+	require.NoError(t, err)
+
+	treeID, conflicted, conflictedFiles, err := MergeTree(t.Context(), repo, "add", "split", mergeBase)
+	require.NoError(t, err)
+	assert.True(t, conflicted)
+	assert.Empty(t, conflictedFiles)
+	assert.Equal(t, "5e3dd4cfc5b11e278a35b2daa83b7274175e3ab1", treeID)
+}
--- a/modules/git/pipeline/catfile.go
+++ b/modules/git/pipeline/catfile.go
@@ -10,6 +10,7 @@ import (
 	"strconv"
 	"strings"

+	"gitea.dev/modules/git"
 	"gitea.dev/modules/git/gitcmd"
 )

@@ -20,13 +21,13 @@ func CatFileBatchCheck(ctx context.Context, cmd *gitcmd.Command, tmpBasePath str
 }

 // CatFileBatchCheckAllObjects runs cat-file with --batch-check --batch-all
-func CatFileBatchCheckAllObjects(ctx context.Context, cmd *gitcmd.Command, tmpBasePath string) error {
-	return cmd.AddArguments("cat-file", "--batch-check", "--batch-all-objects").WithDir(tmpBasePath).RunWithStderr(ctx)
+func CatFileBatchCheckAllObjects(ctx context.Context, cmd *gitcmd.Command, gitRepo *git.Repository) error {
+	return cmd.AddArguments("cat-file", "--batch-check", "--batch-all-objects").WithRepo(gitRepo).RunWithStderr(ctx)
 }

 // CatFileBatch runs cat-file --batch
-func CatFileBatch(ctx context.Context, cmd *gitcmd.Command, tmpBasePath string) error {
-	return cmd.AddArguments("cat-file", "--batch").WithDir(tmpBasePath).RunWithStderr(ctx)
+func CatFileBatch(ctx context.Context, cmd *gitcmd.Command, gitRepo git.RepositoryFacade) error {
+	return cmd.AddArguments("cat-file", "--batch").WithRepo(gitRepo).RunWithStderr(ctx)
 }

 // BlobsLessThan1024FromCatFileBatchCheck reads a pipeline from cat-file --batch-check and returns the blobs <1024 in size
--- a/modules/git/pipeline/lfs_nogogit.go
+++ b/modules/git/pipeline/lfs_nogogit.go
@@ -1,8 +1,6 @@
 // Copyright 2020 The Gitea Authors. All rights reserved.
 // SPDX-License-Identifier: MIT

-//go:build !gogit
-
 package pipeline

 import (
@@ -21,7 +19,7 @@ func FindLFSFile(ctx context.Context, repo *git.Repository, objectID git.ObjectI
 	cmd := gitcmd.NewCommand("rev-list", "--all")
 	revListReader, revListReaderClose := cmd.MakeStdoutPipe()
 	defer revListReaderClose()
-	err := cmd.WithDir(repo.Path).
+	err := cmd.WithRepo(repo).
 		WithPipelineFunc(func(context gitcmd.Context) (err error) {
 			results, err = findLFSFileFunc(ctx, repo, objectID, revListReader)
 			return err
@@ -146,6 +144,6 @@ func findLFSFileFunc(ctx context.Context, repo *git.Repository, objectID git.Obj
 	}

 	sort.Sort(lfsResultSlice(results))
-	err = fillResultNameRev(ctx, repo.Path, results)
+	err = fillResultNameRev(ctx, repo, results)
 	return results, err
 }
--- a/modules/git/pipeline/lfs_gogit.go
+++ b/modules/git/pipeline/lfs_gogit.go
@@ -1,86 +0,0 @@
-// Copyright 2020 The Gitea Authors. All rights reserved.
-// SPDX-License-Identifier: MIT
-
-//go:build gogit
-
-package pipeline
-
-import (
-	"context"
-	"fmt"
-	"io"
-	"sort"
-	"strings"
-
-	"gitea.dev/modules/git"
-
-	gogit "github.com/go-git/go-git/v5"
-	"github.com/go-git/go-git/v5/plumbing"
-	"github.com/go-git/go-git/v5/plumbing/object"
-)
-
-// FindLFSFile finds commits that contain a provided pointer file hash
-func FindLFSFile(ctx context.Context, repo *git.Repository, objectID git.ObjectID) ([]*LFSResult, error) {
-	resultsMap := map[string]*LFSResult{}
-	results := make([]*LFSResult, 0)
-
-	gogitRepo := repo.GoGitRepo()
-
-	commitsIter, err := gogitRepo.Log(&gogit.LogOptions{
-		Order: gogit.LogOrderCommitterTime,
-		All:   true,
-	})
-	if err != nil {
-		return nil, fmt.Errorf("LFS error occurred, failed to get GoGit CommitsIter: err: %w", err)
-	}
-
-	err = commitsIter.ForEach(func(gitCommit *object.Commit) error {
-		tree, err := gitCommit.Tree()
-		if err != nil {
-			return err
-		}
-		treeWalker := object.NewTreeWalker(tree, true, nil)
-		defer treeWalker.Close()
-		for {
-			name, entry, err := treeWalker.Next()
-			if err == io.EOF {
-				break
-			}
-			if entry.Hash == plumbing.Hash(objectID.RawValue()) {
-				parents := make([]git.ObjectID, len(gitCommit.ParentHashes))
-				for i, parentCommitID := range gitCommit.ParentHashes {
-					parents[i] = git.ParseGogitHash(parentCommitID)
-				}
-
-				result := LFSResult{
-					Name:         name,
-					SHA:          gitCommit.Hash.String(),
-					Summary:      strings.Split(strings.TrimSpace(gitCommit.Message), "\n")[0],
-					When:         gitCommit.Author.When,
-					ParentHashes: parents,
-				}
-				resultsMap[gitCommit.Hash.String()+":"+name] = &result
-			}
-		}
-		return nil
-	})
-	if err != nil && err != io.EOF {
-		return nil, fmt.Errorf("LFS error occurred, failure in CommitIter.ForEach: %w", err)
-	}
-
-	for _, result := range resultsMap {
-		hasParent := false
-		for _, parentHash := range result.ParentHashes {
-			if _, hasParent = resultsMap[parentHash.String()+":"+result.Name]; hasParent {
-				break
-			}
-		}
-		if !hasParent {
-			results = append(results, result)
-		}
-	}
-
-	sort.Sort(lfsResultSlice(results))
-	err = fillResultNameRev(ctx, repo.Path, results)
-	return results, err
-}
--- a/modules/git/pipeline/namerev.go
+++ b/modules/git/pipeline/namerev.go
@@ -9,15 +9,16 @@ import (
 	"errors"
 	"strings"

+	"gitea.dev/modules/git"
 	"gitea.dev/modules/git/gitcmd"

 	"golang.org/x/sync/errgroup"
 )

-func fillResultNameRev(ctx context.Context, basePath string, results []*LFSResult) error {
+func fillResultNameRev(ctx context.Context, repo git.RepositoryFacade, results []*LFSResult) error {
 	// Should really use a go-git function here but name-rev is not completed and recapitulating it is not simple
 	wg := errgroup.Group{}
-	cmd := gitcmd.NewCommand("name-rev", "--stdin", "--name-only", "--always").WithDir(basePath)
+	cmd := gitcmd.NewCommand("name-rev", "--stdin", "--name-only", "--always").WithRepo(repo)
 	stdin, stdinClose := cmd.MakeStdinPipe()
 	stdout, stdoutClose := cmd.MakeStdoutPipe()
 	defer stdinClose()
--- a/modules/git/push.go
+++ b/modules/git/push.go
@@ -0,0 +1,27 @@
+// Copyright 2025 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package git
+
+import (
+	"context"
+
+	"gitea.dev/modules/git/gitcmd"
+)
+
+// PushToExternal pushes a managed repository to an external remote.
+func PushToExternal(ctx context.Context, repo RepositoryFacade, opts PushOptions) error {
+	return Push(ctx, gitcmd.RepoLocalPath(repo), opts)
+}
+
+// PushManaged pushes from one managed repository to another managed repository.
+func PushManaged(ctx context.Context, fromRepo, toRepo RepositoryFacade, opts PushOptions) error {
+	opts.Remote = gitcmd.RepoLocalPath(toRepo)
+	return Push(ctx, gitcmd.RepoLocalPath(fromRepo), opts)
+}
+
+// PushFromLocal pushes from a local path to a managed repository.
+func PushFromLocal(ctx context.Context, fromLocalPath string, toRepo RepositoryFacade, opts PushOptions) error {
+	opts.Remote = gitcmd.RepoLocalPath(toRepo)
+	return Push(ctx, fromLocalPath, opts)
+}
--- a/modules/git/ref.go
+++ b/modules/git/ref.go
@@ -8,6 +8,7 @@ import (
 	"regexp"
 	"strings"

+	"gitea.dev/modules/git/gitcmd"
 	"gitea.dev/modules/setting"
 	"gitea.dev/modules/util"
 )
@@ -242,3 +243,11 @@ func ParseRefSuffix(ref string) (refName, refSuffix string) {
 	}
 	return ref[:suffixIdx], ref[suffixIdx:]
 }
+
+func UpdateRef(ctx context.Context, repo RepositoryFacade, refName, newCommitID string) error {
+	return gitcmd.NewCommand("update-ref").AddDynamicArguments(refName, newCommitID).WithRepo(repo).Run(ctx)
+}
+
+func RemoveRef(ctx context.Context, repo RepositoryFacade, refName string) error {
+	return gitcmd.NewCommand("update-ref", "--no-deref", "-d").AddDynamicArguments(refName).WithRepo(repo).Run(ctx)
+}
--- a/modules/git/remote_managed.go
+++ b/modules/git/remote_managed.go
@@ -0,0 +1,57 @@
+// Copyright 2025 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package git
+
+import (
+	"context"
+	"errors"
+
+	"gitea.dev/modules/git/gitcmd"
+	giturl "gitea.dev/modules/git/url"
+	"gitea.dev/modules/util"
+)
+
+type RemoteOption string
+
+const (
+	RemoteOptionMirrorPush  RemoteOption = "--mirror=push"
+	RemoteOptionMirrorFetch RemoteOption = "--mirror=fetch"
+)
+
+func ManagedRemoteAdd(ctx context.Context, repo RepositoryFacade, remoteName, remoteURL string, options ...RemoteOption) error {
+	return LockConfigAndDo(ctx, repo, func(ctx context.Context) error {
+		cmd := gitcmd.NewCommand("remote", "add")
+		if len(options) > 0 {
+			switch options[0] {
+			case RemoteOptionMirrorPush:
+				cmd.AddArguments("--mirror=push")
+			case RemoteOptionMirrorFetch:
+				cmd.AddArguments("--mirror=fetch")
+			default:
+				return errors.New("unknown remote option: " + string(options[0]))
+			}
+		}
+		_, _, err := cmd.AddDynamicArguments(remoteName, remoteURL).WithRepo(repo).RunStdString(ctx)
+		return err
+	})
+}
+
+func ManagedRemoteRemove(ctx context.Context, repo RepositoryFacade, remoteName string) error {
+	return LockConfigAndDo(ctx, repo, func(ctx context.Context) error {
+		cmd := gitcmd.NewCommand("remote", "rm").AddDynamicArguments(remoteName)
+		_, _, err := cmd.WithRepo(repo).RunStdString(ctx)
+		return err
+	})
+}
+
+func ParseRemoteAddressURL(ctx context.Context, repo RepositoryFacade, remoteName string) (*giturl.GitURL, error) {
+	addr, err := GetRemoteAddress(ctx, repo, remoteName)
+	if err != nil {
+		return nil, err
+	}
+	if addr == "" {
+		return nil, util.NewNotExistErrorf("remote '%s' does not exist", remoteName)
+	}
+	return giturl.ParseGitURL(addr)
+}
--- a/modules/git/repo.go
+++ b/modules/git/repo.go
@@ -13,6 +13,7 @@ import (
 	"path/filepath"
 	"strconv"
 	"strings"
+	"sync"
 	"time"

 	"gitea.dev/modules/git/gitcmd"
@@ -24,13 +25,20 @@ import (
 type RepositoryFacade = gitcmd.RepositoryFacade

 type RepositoryBase struct {
-	Path string // absolute path
+	// TODO: refactor it to a private field "localPath" in the future
+	// * for repo accessing purpose, in most causes, use "WithRepo", or RepoLocalPath(repo) if the local path must be used
+	// * for error handling & logging purpose, it needs to introduce a new function "git.RepoLogName()" to handle various cases
+	Path string

 	LastCommitCache *LastCommitCache

 	repoFacade        RepositoryFacade
 	tagCache          *ObjectCache[*Tag]
 	objectFormatCache ObjectFormat
+
+	mu                 sync.Mutex
+	catFileBatchCloser CatFileBatchCloser
+	catFileBatchInUse  bool
 }

 var _ gitcmd.RepositoryFacade = (*Repository)(nil)
@@ -78,6 +86,14 @@ func (repo *Repository) Close() error {
 	}
 	repo.LastCommitCache = nil
 	repo.tagCache = nil
+
+	repo.mu.Lock()
+	defer repo.mu.Unlock()
+	if repo.catFileBatchCloser != nil {
+		repo.catFileBatchCloser.Close()
+		repo.catFileBatchCloser = nil
+		repo.catFileBatchInUse = false
+	}
 	return repo.closeInternal()
 }

@@ -87,8 +103,8 @@ func IsRepoURLAccessible(ctx context.Context, url string) bool {
 	return err == nil
 }

-// InitRepository initializes a new Git repository.
-func InitRepository(ctx context.Context, repoPath string, bare bool, objectFormatName string) error {
+// InitRepositoryLocal initializes a new Git repository.
+func InitRepositoryLocal(ctx context.Context, repoPath string, bare bool, objectFormatName string) error {
 	err := os.MkdirAll(repoPath, os.ModePerm)
 	if err != nil {
 		return err
@@ -115,7 +131,7 @@ func (repo *Repository) IsEmpty(ctx context.Context) (bool, error) {
 	stdout, _, err := gitcmd.NewCommand().
 		AddOptionFormat("--git-dir=%s", repo.Path).
 		AddArguments("rev-list", "-n", "1", "--all").
-		WithDir(repo.Path).
+		WithRepo(repo).
 		RunStdString(ctx)
 	if err != nil {
 		if (gitcmd.IsErrorExitCode(err, 1) && err.Stderr() == "") || gitcmd.IsErrorExitCode(err, 129) {
@@ -255,3 +271,41 @@ func Push(ctx context.Context, repoPath string, opts PushOptions) error {

 	return nil
 }
+
+// CatFileBatch obtains a "batch object provider" for this repository.
+// It reuses an existing one if available, otherwise creates a new one.
+func (repo *Repository) CatFileBatch(ctx context.Context) (_ CatFileBatch, closeFunc func(), err error) {
+	repo.mu.Lock()
+	defer repo.mu.Unlock()
+
+	if repo.catFileBatchCloser != nil && !repo.catFileBatchInUse {
+		if ctx != repo.catFileBatchCloser.Context() {
+			repo.catFileBatchCloser.Close()
+			repo.catFileBatchCloser = nil
+			repo.catFileBatchInUse = false
+		}
+	}
+
+	if repo.catFileBatchCloser == nil {
+		repo.catFileBatchCloser, err = NewBatch(ctx, repo)
+		if err != nil {
+			repo.catFileBatchCloser = nil // otherwise it is "interface(nil)" and will cause wrong logic
+			return nil, nil, err
+		}
+	}
+
+	if !repo.catFileBatchInUse {
+		repo.catFileBatchInUse = true
+		return CatFileBatch(repo.catFileBatchCloser), func() {
+			repo.mu.Lock()
+			defer repo.mu.Unlock()
+			repo.catFileBatchInUse = false
+		}, nil
+	}
+
+	tempBatch, err := NewBatch(ctx, repo)
+	if err != nil {
+		return nil, nil, err
+	}
+	return tempBatch, tempBatch.Close, nil
+}
--- a/modules/git/repo_base_nogogit.go
+++ b/modules/git/repo_base_nogogit.go
@@ -6,73 +6,16 @@

 package git

-import (
-	"context"
-	"sync"
-
-	"gitea.dev/modules/log"
-)
-
 const isGogit = false

 type Repository struct {
 	RepositoryBase
-
-	mu                 sync.Mutex
-	catFileBatchCloser CatFileBatchCloser
-	catFileBatchInUse  bool
 }

 func openRepositoryInternal(_ *Repository) error {
 	return nil
 }

-// CatFileBatch obtains a "batch object provider" for this repository.
-// It reuses an existing one if available, otherwise creates a new one.
-func (repo *Repository) CatFileBatch(ctx context.Context) (_ CatFileBatch, closeFunc func(), err error) {
-	repo.mu.Lock()
-	defer repo.mu.Unlock()
-
-	if repo.catFileBatchCloser != nil && !repo.catFileBatchInUse {
-		if ctx != repo.catFileBatchCloser.Context() {
-			repo.catFileBatchCloser.Close()
-			repo.catFileBatchCloser = nil
-			repo.catFileBatchInUse = false
-		}
-	}
-
-	if repo.catFileBatchCloser == nil {
-		repo.catFileBatchCloser, err = NewBatch(ctx, repo)
-		if err != nil {
-			repo.catFileBatchCloser = nil // otherwise it is "interface(nil)" and will cause wrong logic
-			return nil, nil, err
-		}
-	}
-
-	if !repo.catFileBatchInUse {
-		repo.catFileBatchInUse = true
-		return CatFileBatch(repo.catFileBatchCloser), func() {
-			repo.mu.Lock()
-			defer repo.mu.Unlock()
-			repo.catFileBatchInUse = false
-		}, nil
-	}
-
-	log.Debug("Opening temporary cat file batch for: %s", repo.Path)
-	tempBatch, err := NewBatch(ctx, repo)
-	if err != nil {
-		return nil, nil, err
-	}
-	return tempBatch, tempBatch.Close, nil
-}
-
 func (repo *Repository) closeInternal() error {
-	repo.mu.Lock()
-	defer repo.mu.Unlock()
-	if repo.catFileBatchCloser != nil {
-		repo.catFileBatchCloser.Close()
-		repo.catFileBatchCloser = nil
-		repo.catFileBatchInUse = false
-	}
 	return nil
 }
--- a/modules/git/repo_branch.go
+++ b/modules/git/repo_branch.go
@@ -20,7 +20,7 @@ func (repo *Repository) AddRemote(ctx context.Context, name, url string, fetch b
 		cmd.AddArguments("-f")
 	}
 	_, _, err := cmd.AddDynamicArguments(name, url).
-		WithDir(repo.Path).
+		WithRepo(repo).
 		RunStdString(ctx)
 	return err
 }
--- a/modules/git/repo_commit.go
+++ b/modules/git/repo_commit.go
@@ -50,7 +50,7 @@ const prettyLogFormat = `--pretty=format:%H`
 func (repo *Repository) ShowPrettyFormatLogToList(ctx context.Context, revisionRange string) ([]*Commit, error) {
 	// avoid: ambiguous argument 'refs/a...refs/b': unknown revision or path not in the working tree. Use '--': 'git <command> [<revision>...] -- [<file>...]'
 	logs, _, err := gitcmd.NewCommand("log").AddArguments(prettyLogFormat).
-		AddDynamicArguments(revisionRange).AddArguments("--").WithDir(repo.Path).
+		AddDynamicArguments(revisionRange).AddArguments("--").WithRepo(repo).
 		RunStdBytes(ctx)
 	if err != nil {
 		return nil, err
@@ -86,7 +86,7 @@ func (repo *Repository) getCommitByPathWithID(ctx context.Context, id ObjectID,
 	stdout, _, runErr := gitcmd.NewCommand("log", "-1", prettyLogFormat).
 		AddDynamicArguments(id.String()).
 		AddDashesAndList(relpath).
-		WithDir(repo.Path).
+		WithRepo(repo).
 		RunStdString(ctx)
 	if runErr != nil {
 		return nil, runErr
@@ -104,7 +104,7 @@ func (repo *Repository) getCommitByPathWithID(ctx context.Context, id ObjectID,
 func (repo *Repository) GetCommitByPath(ctx context.Context, relpath string) (*Commit, error) {
 	stdout, _, runErr := gitcmd.NewCommand("log", "-1", prettyLogFormat).
 		AddDashesAndList(relpath).
-		WithDir(repo.Path).
+		WithRepo(repo).
 		RunStdBytes(ctx)
 	if runErr != nil {
 		return nil, runErr
@@ -138,7 +138,7 @@ func (repo *Repository) commitsByRangeWithTime(ctx context.Context, id ObjectID,
 		cmd.AddOptionFormat("--until=%s", until)
 	}

-	stdout, _, err := cmd.WithDir(repo.Path).RunStdBytes(ctx)
+	stdout, _, err := cmd.WithRepo(repo).RunStdBytes(ctx)
 	if err != nil {
 		return nil, err
 	}
@@ -192,7 +192,7 @@ func (repo *Repository) searchCommits(ctx context.Context, id ObjectID, opts Sea

 	// search for commits matching given constraints and keywords in commit msg
 	addCommonSearchArgs(cmd)
-	stdout, _, err := cmd.WithDir(repo.Path).RunStdBytes(ctx)
+	stdout, _, err := cmd.WithRepo(repo).RunStdBytes(ctx)
 	if err != nil {
 		return nil, err
 	}
@@ -213,7 +213,7 @@ func (repo *Repository) searchCommits(ctx context.Context, id ObjectID, opts Sea
 			hashCmd.AddDynamicArguments(v)

 			// search with given constraints for commit matching sha hash of v
-			hashMatching, _, err := hashCmd.WithDir(repo.Path).RunStdBytes(ctx)
+			hashMatching, _, err := hashCmd.WithRepo(repo).RunStdBytes(ctx)
 			if err != nil || bytes.Contains(stdout, hashMatching) {
 				continue
 			}
@@ -231,7 +231,7 @@ func (repo *Repository) FileChangedBetweenCommits(ctx context.Context, filename,
 	stdout, _, err := gitcmd.NewCommand("diff", "--name-only", "-z").
 		AddDynamicArguments(id1, id2).
 		AddDashesAndList(filename).
-		WithDir(repo.Path).
+		WithRepo(repo).
 		RunStdBytes(ctx)
 	if err != nil {
 		return false, err
@@ -275,7 +275,7 @@ func (repo *Repository) CommitsByFileAndRange(ctx context.Context, opts CommitsB

 	stdoutReader, stdoutReaderClose := gitCmd.MakeStdoutPipe()
 	defer stdoutReaderClose()
-	err := gitCmd.WithDir(repo.Path).
+	err := gitCmd.WithRepo(repo).
 		WithPipelineFunc(func(context gitcmd.Context) error {
 			objectFormat, err := repo.GetObjectFormat(ctx)
 			if err != nil {
@@ -316,7 +316,7 @@ func (repo *Repository) CommitsByFileAndRange(ctx context.Context, opts CommitsB
 // If "before" and "after" are not related, it returns the all commits for the "after" commit.
 func (repo *Repository) CommitsBetween(ctx context.Context, afterRef, beforeRef RefName, limit int, optSkip ...int) ([]*Commit, error) {
 	gitCmd := func() *gitcmd.Command {
-		cmd := gitcmd.NewCommand("rev-list").WithDir(repo.Path)
+		cmd := gitcmd.NewCommand("rev-list").WithRepo(repo)
 		if limit >= 0 {
 			cmd.AddOptionValues("--max-count", strconv.Itoa(limit))
 		}
@@ -351,7 +351,7 @@ func (repo *Repository) commitsBefore(ctx context.Context, id ObjectID, limit in
 	}
 	cmd.AddDynamicArguments(id.String())

-	stdout, _, runErr := cmd.WithDir(repo.Path).RunStdBytes(ctx)
+	stdout, _, runErr := cmd.WithRepo(repo).RunStdBytes(ctx)
 	if runErr != nil {
 		return nil, runErr
 	}
@@ -392,7 +392,7 @@ func (repo *Repository) getBranches(ctx context.Context, env []string, commitID
 		AddOptionValues("--contains", commitID).
 		AddArguments(BranchPrefix).
 		WithEnv(env).
-		WithDir(repo.Path).
+		WithRepo(repo).
 		RunStdString(ctx)
 	if err != nil {
 		return nil, err
@@ -418,7 +418,7 @@ func (repo *Repository) GetCommitsFromIDs(ctx context.Context, commitIDs []strin
 func (repo *Repository) IsCommitInBranch(ctx context.Context, commitID, branch string) (r bool, err error) {
 	stdout, _, err := gitcmd.NewCommand("branch", "--contains").
 		AddDynamicArguments(commitID, branch).
-		WithDir(repo.Path).
+		WithRepo(repo).
 		RunStdString(ctx)
 	if err != nil {
 		return false, err
@@ -431,7 +431,7 @@ func (repo *Repository) GetCommitBranchStart(ctx context.Context, env []string,
 	cmd := gitcmd.NewCommand("log", prettyLogFormat)
 	cmd.AddDynamicArguments(endCommitID)

-	stdout, _, runErr := cmd.WithDir(repo.Path).
+	stdout, _, runErr := cmd.WithRepo(repo).
 		WithEnv(env).
 		RunStdBytes(ctx)
 	if runErr != nil {
--- a/modules/git/repo_commit_gogit.go
+++ b/modules/git/repo_commit_gogit.go
@@ -57,7 +57,7 @@ func (repo *Repository) ConvertToGitID(ctx context.Context, commitID string) (Ob

 	actualCommitID, _, err := gitcmd.NewCommand("rev-parse", "--verify").
 		AddDynamicArguments(commitID).
-		WithDir(repo.Path).
+		WithRepo(repo).
 		RunStdString(ctx)
 	actualCommitID = strings.TrimSpace(actualCommitID)
 	if err != nil {
--- a/modules/git/repo_commit_nogogit.go
+++ b/modules/git/repo_commit_nogogit.go
@@ -19,7 +19,7 @@ import (
 func (repo *Repository) ResolveReference(ctx context.Context, name string) (string, error) {
 	stdout, _, err := gitcmd.NewCommand("show-ref", "--hash").
 		AddDynamicArguments(name).
-		WithDir(repo.Path).
+		WithRepo(repo).
 		RunStdString(ctx)
 	if err != nil {
 		if strings.Contains(err.Error(), "not a valid ref") {
--- a/modules/git/repo_compare.go
+++ b/modules/git/repo_compare.go
@@ -11,8 +11,6 @@ import (
 	"errors"
 	"fmt"
 	"io"
-	"os"
-	"path/filepath"
 	"regexp"
 	"strings"

@@ -44,7 +42,7 @@ func (repo *Repository) GetDiffNumChangedFiles(ctx context.Context, base, head s
 	if err := gitcmd.NewCommand("diff", "-z", "--name-only").
 		AddDynamicArguments(base + separator + head).
 		AddArguments("--").
-		WithDir(repo.Path).
+		WithRepo(repo).
 		WithStdoutCopy(w).
 		RunWithStderr(ctx); err != nil {
 		if gitcmd.IsStderr(err, gitcmd.StderrNoMergeBase) {
@@ -62,7 +60,7 @@ var patchCommits = regexp.MustCompile(`^From\s(\w+)\s`)
 // GetDiff generates and returns patch data between given revisions, optimized for human readability
 func (repo *Repository) GetDiff(ctx context.Context, compareArg string, w io.Writer) error {
 	return gitcmd.NewCommand("diff", "-p").AddDynamicArguments(compareArg).
-		WithDir(repo.Path).
+		WithRepo(repo).
 		WithStdoutCopy(w).
 		Run(ctx)
 }
@@ -71,7 +69,7 @@ func (repo *Repository) GetDiff(ctx context.Context, compareArg string, w io.Wri
 func (repo *Repository) GetDiffBinary(ctx context.Context, compareArg string, w io.Writer) error {
 	return gitcmd.NewCommand("diff", "-p", "--binary", "--histogram").
 		AddDynamicArguments(compareArg).
-		WithDir(repo.Path).
+		WithRepo(repo).
 		WithStdoutCopy(w).
 		Run(ctx)
 }
@@ -79,7 +77,7 @@ func (repo *Repository) GetDiffBinary(ctx context.Context, compareArg string, w
 // GetPatch generates and returns format-patch data between given revisions, able to be used with `git apply`
 func (repo *Repository) GetPatch(ctx context.Context, compareArg string, w io.Writer) error {
 	return gitcmd.NewCommand("format-patch", "--binary", "--stdout").AddDynamicArguments(compareArg).
-		WithDir(repo.Path).
+		WithRepo(repo).
 		WithStdoutCopy(w).
 		Run(ctx)
 }
@@ -98,7 +96,7 @@ func (repo *Repository) GetFilesChangedBetween(ctx context.Context, base, head s
 	} else {
 		cmd.AddDynamicArguments(base, head)
 	}
-	stdout, _, err := cmd.WithDir(repo.Path).RunStdString(ctx)
+	stdout, _, err := cmd.WithRepo(repo).RunStdString(ctx)
 	if err != nil {
 		return nil, err
 	}
@@ -115,8 +113,8 @@ func (repo *Repository) GetFilesChangedBetween(ctx context.Context, base, head s
 // ReadPatchCommit will check if a diff patch exists and return stats
 func (repo *Repository) ReadPatchCommit(prID int64) (commitSHA string, err error) {
 	// Migrated repositories download patches to "pulls" location
-	patchFile := fmt.Sprintf("pulls/%d.patch", prID)
-	loadPatch, err := os.Open(filepath.Join(repo.Path, patchFile))
+	repoFS := GetRepoFS(repo)
+	loadPatch, err := repoFS.Open(fmt.Sprintf("pulls/%d.patch", prID))
 	if err != nil {
 		return "", err
 	}
--- a/modules/git/repo_compare_test.go
+++ b/modules/git/repo_compare_test.go
@@ -103,7 +103,7 @@ func TestReadWritePullHead(t *testing.T) {
 	newCommit := "feaf4ba6bc635fec442f46ddd4512416ec43c2c2"
 	_, _, err = gitcmd.NewCommand("update-ref").
 		AddDynamicArguments(PullPrefix+"1/head", newCommit).
-		WithDir(repo.Path).
+		WithRepo(repo).
 		RunStdString(t.Context())
 	if err != nil {
 		assert.NoError(t, err)
@@ -123,7 +123,7 @@ func TestReadWritePullHead(t *testing.T) {
 	// Remove file after the test
 	_, _, err = gitcmd.NewCommand("update-ref", "--no-deref", "-d").
 		AddDynamicArguments(PullPrefix + "1/head").
-		WithDir(repo.Path).
+		WithRepo(repo).
 		RunStdString(t.Context())
 	assert.NoError(t, err)
 }
--- a/modules/git/repo_index.go
+++ b/modules/git/repo_index.go
@@ -22,7 +22,7 @@ func (repo *Repository) ReadTreeToIndex(ctx context.Context, treeish string, ind
 	}

 	if len(treeish) != objectFormat.FullLength() {
-		res, _, err := gitcmd.NewCommand("rev-parse", "--verify").AddDynamicArguments(treeish).WithDir(repo.Path).RunStdString(ctx)
+		res, _, err := gitcmd.NewCommand("rev-parse", "--verify").AddDynamicArguments(treeish).WithRepo(repo).RunStdString(ctx)
 		if err != nil {
 			return err
 		}
@@ -42,7 +42,7 @@ func (repo *Repository) readTreeToIndex(ctx context.Context, id ObjectID, indexF
 	if len(indexFilename) > 0 {
 		env = append(os.Environ(), "GIT_INDEX_FILE="+indexFilename[0])
 	}
-	_, _, err := gitcmd.NewCommand("read-tree").AddDynamicArguments(id.String()).WithDir(repo.Path).WithEnv(env).RunStdString(ctx)
+	_, _, err := gitcmd.NewCommand("read-tree").AddDynamicArguments(id.String()).WithRepo(repo).WithEnv(env).RunStdString(ctx)
 	if err != nil {
 		return err
 	}
@@ -75,14 +75,14 @@ func (repo *Repository) ReadTreeToTemporaryIndex(ctx context.Context, treeish st

 // EmptyIndex empties the index
 func (repo *Repository) EmptyIndex(ctx context.Context) error {
-	_, _, err := gitcmd.NewCommand("read-tree", "--empty").WithDir(repo.Path).RunStdString(ctx)
+	_, _, err := gitcmd.NewCommand("read-tree", "--empty").WithRepo(repo).RunStdString(ctx)
 	return err
 }

 // LsFiles checks if the given filenames are in the index
 func (repo *Repository) LsFiles(ctx context.Context, filenames ...string) ([]string, error) {
 	cmd := gitcmd.NewCommand("ls-files", "-z").AddDashesAndList(filenames...)
-	res, _, err := cmd.WithDir(repo.Path).RunStdBytes(ctx)
+	res, _, err := cmd.WithRepo(repo).RunStdBytes(ctx)
 	if err != nil {
 		return nil, err
 	}
@@ -109,7 +109,7 @@ func (repo *Repository) RemoveFilesFromIndex(ctx context.Context, filenames ...s
 		}
 	}
 	return cmd.
-		WithDir(repo.Path).
+		WithRepo(repo).
 		WithStdinBytes(input.Bytes()).
 		RunWithStderr(ctx)
 }
@@ -129,7 +129,7 @@ func (repo *Repository) AddObjectsToIndex(ctx context.Context, objects ...IndexO
 		input.WriteString(object.Mode + " blob " + object.Object.String() + "\t" + object.Filename + "\000")
 	}
 	return cmd.
-		WithDir(repo.Path).
+		WithRepo(repo).
 		WithStdinBytes(input.Bytes()).
 		RunWithStderr(ctx)
 }
@@ -141,7 +141,7 @@ func (repo *Repository) AddObjectToIndex(ctx context.Context, mode string, objec

 // WriteTree writes the current index as a tree to the object db and returns its hash
 func (repo *Repository) WriteTree(ctx context.Context) (*Tree, error) {
-	stdout, _, runErr := gitcmd.NewCommand("write-tree").WithDir(repo.Path).RunStdString(ctx)
+	stdout, _, runErr := gitcmd.NewCommand("write-tree").WithRepo(repo).RunStdString(ctx)
 	if runErr != nil {
 		return nil, runErr
 	}
--- a/modules/git/repo_object.go
+++ b/modules/git/repo_object.go
@@ -68,7 +68,7 @@ func (repo *Repository) hashObjectBytes(ctx context.Context, buf []byte, save bo
 		cmd = gitcmd.NewCommand("hash-object", "--stdin")
 	}
 	stdout, _, err := cmd.
-		WithDir(repo.Path).
+		WithRepo(repo).
 		WithStdinBytes(buf).
 		RunStdString(ctx)
 	if err != nil {
--- a/modules/git/repo_ref.go
+++ b/modules/git/repo_ref.go
@@ -30,7 +30,7 @@ func (repo *Repository) ListOccurrences(ctx context.Context, refType, commitSHA
 		return nil, util.NewInvalidArgumentErrorf(`can only use "branch" or "tag" for refType, but got %q`, refType)
 	}
 	stdout, _, err := cmd.AddArguments("--no-color", "--sort=-creatordate", "--contains").
-		AddDynamicArguments(commitSHA).WithDir(repo.Path).RunStdString(ctx)
+		AddDynamicArguments(commitSHA).WithRepo(repo).RunStdString(ctx)
 	if err != nil {
 		return nil, err
 	}
--- a/modules/git/repo_ref_nogogit.go
+++ b/modules/git/repo_ref_nogogit.go
@@ -20,7 +20,7 @@ func (repo *Repository) GetRefsFiltered(ctx context.Context, pattern string) ([]
 	cmd := gitcmd.NewCommand("for-each-ref")
 	stdoutReader, stdoutReaderClose := cmd.MakeStdoutPipe()
 	defer stdoutReaderClose()
-	err := cmd.WithDir(repo.Path).
+	err := cmd.WithRepo(repo).
 		WithPipelineFunc(func(context gitcmd.Context) error {
 			bufReader := bufio.NewReader(stdoutReader)
 			for {
--- a/modules/git/repo_stats.go
+++ b/modules/git/repo_stats.go
@@ -42,7 +42,7 @@ func (repo *Repository) GetCodeActivityStats(ctx context.Context, fromTime time.

 	stdout, _, runErr := gitcmd.NewCommand("rev-list", "--count", "--no-merges", "--branches=*", "--date=iso").
 		AddOptionFormat("--since=%s", since).
-		WithDir(repo.Path).
+		WithRepo(repo).
 		RunStdString(ctx)
 	if runErr != nil {
 		return nil, runErr
@@ -65,7 +65,7 @@ func (repo *Repository) GetCodeActivityStats(ctx context.Context, fromTime time.
 	stdoutReader, stdoutReaderClose := gitCmd.MakeStdoutPipe()
 	defer stdoutReaderClose()
 	err = gitCmd.
-		WithDir(repo.Path).
+		WithRepo(repo).
 		WithPipelineFunc(func(ctx gitcmd.Context) error {
 			scanner := bufio.NewScanner(stdoutReader)
 			scanner.Split(bufio.ScanLines)
--- a/modules/git/repo_tag.go
+++ b/modules/git/repo_tag.go
@@ -19,7 +19,7 @@ const TagPrefix = "refs/tags/"

 // CreateTag create one tag in the repository
 func (repo *Repository) CreateTag(ctx context.Context, name, revision string) error {
-	_, _, err := gitcmd.NewCommand("tag").AddDashesAndList(name, revision).WithDir(repo.Path).RunStdString(ctx)
+	_, _, err := gitcmd.NewCommand("tag").AddDashesAndList(name, revision).WithRepo(repo).RunStdString(ctx)
 	return err
 }

@@ -28,7 +28,7 @@ func (repo *Repository) CreateAnnotatedTag(ctx context.Context, name, message, r
 	_, _, err := gitcmd.NewCommand("tag", "-a", "-m").
 		AddDynamicArguments(message).
 		AddDashesAndList(name, revision).
-		WithDir(repo.Path).
+		WithRepo(repo).
 		RunStdString(ctx)
 	return err
 }
@@ -39,7 +39,7 @@ func (repo *Repository) GetTagNameBySHA(ctx context.Context, sha string) (string
 		return "", fmt.Errorf("SHA is too short: %s", sha)
 	}

-	stdout, _, err := gitcmd.NewCommand("show-ref", "--tags", "-d").WithDir(repo.Path).RunStdString(ctx)
+	stdout, _, err := gitcmd.NewCommand("show-ref", "--tags", "-d").WithRepo(repo).RunStdString(ctx)
 	if err != nil {
 		return "", err
 	}
@@ -62,7 +62,7 @@ func (repo *Repository) GetTagNameBySHA(ctx context.Context, sha string) (string

 // GetTagID returns the object ID for a tag (annotated tags have both an object SHA AND a commit SHA)
 func (repo *Repository) GetTagID(ctx context.Context, name string) (string, error) {
-	stdout, _, err := gitcmd.NewCommand("show-ref", "--tags").AddDashesAndList(name).WithDir(repo.Path).RunStdString(ctx)
+	stdout, _, err := gitcmd.NewCommand("show-ref", "--tags").AddDashesAndList(name).WithRepo(repo).RunStdString(ctx)
 	if err != nil {
 		return "", err
 	}
@@ -122,7 +122,7 @@ func (repo *Repository) GetTagInfos(ctx context.Context, page, pageSize int) ([]
 	defer stdoutReaderClose()
 	err := cmd.AddOptionFormat("--format=%s", forEachRefFmt.Flag()).
 		AddArguments("--sort", "-*creatordate", "refs/tags").
-		WithDir(repo.Path).
+		WithRepo(repo).
 		WithPipelineFunc(func(context gitcmd.Context) error {
 			parser := forEachRefFmt.Parser(stdoutReader)
 			for {
--- a/modules/git/repo_tree.go
+++ b/modules/git/repo_tree.go
@@ -60,7 +60,7 @@ func (repo *Repository) CommitTree(ctx context.Context, author, committer *Signa
 	}

 	stdout, _, err := cmd.WithEnv(env).
-		WithDir(repo.Path).
+		WithRepo(repo).
 		WithStdinBytes(messageBytes.Bytes()).
 		RunStdString(ctx)
 	if err != nil {
--- a/modules/git/repo_tree_gogit.go
+++ b/modules/git/repo_tree_gogit.go
@@ -41,7 +41,7 @@ func (repo *Repository) GetTree(ctx context.Context, idStr string) (*Tree, error
 	if len(idStr) != objectFormat.FullLength() {
 		res, _, err := gitcmd.NewCommand("rev-parse", "--verify").
 			AddDynamicArguments(idStr).
-			WithDir(repo.Path).
+			WithRepo(repo).
 			RunStdString(ctx)
 		if err != nil {
 			return nil, err
--- a/modules/git/size.go
+++ b/modules/git/size.go
@@ -0,0 +1,39 @@
+// Copyright 2025 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package git
+
+import (
+	"os"
+	"path/filepath"
+
+	"gitea.dev/modules/git/gitcmd"
+)
+
+const notRegularFileMode = os.ModeSymlink | os.ModeNamedPipe | os.ModeSocket | os.ModeDevice | os.ModeCharDevice | os.ModeIrregular
+
+// CalcRepositorySize returns the disk consumption for a given path
+func CalcRepositorySize(repo RepositoryFacade) (int64, error) {
+	var size int64
+	err := filepath.WalkDir(gitcmd.RepoLocalPath(repo), func(_ string, entry os.DirEntry, err error) error {
+		if os.IsNotExist(err) { // ignore the error because some files (like temp/lock file) may be deleted during traversing.
+			return nil
+		} else if err != nil {
+			return err
+		}
+		if entry.IsDir() {
+			return nil
+		}
+		info, err := entry.Info()
+		if os.IsNotExist(err) { // ignore the error as above
+			return nil
+		} else if err != nil {
+			return err
+		}
+		if (info.Mode() & notRegularFileMode) == 0 {
+			size += info.Size()
+		}
+		return nil
+	})
+	return size, err
+}
--- a/modules/git/tag.go
+++ b/modules/git/tag.go
@@ -5,6 +5,7 @@ package git

 import (
 	"bytes"
+	"context"
 	"sort"

 	"gitea.dev/modules/util"
@@ -114,3 +115,8 @@ func sortTagsByTime(tags []*Tag) {
 	sorter := tagSorter(tags)
 	sort.Sort(sorter)
 }
+
+// IsTagExist returns true if given tag exists in the repository.
+func IsTagExist(ctx context.Context, repo RepositoryFacade, name string) bool {
+	return IsReferenceExist(ctx, repo, TagPrefix+name)
+}
--- a/modules/git/tree.go
+++ b/modules/git/tree.go
@@ -53,7 +53,7 @@ func (repo *Repository) LsTree(ctx context.Context, ref string, filenames ...str
 	cmd := gitcmd.NewCommand("ls-tree", "-z", "--name-only").
 		AddDashesAndList(append([]string{ref}, filenames...)...)

-	res, _, err := cmd.WithDir(repo.Path).RunStdBytes(ctx)
+	res, _, err := cmd.WithRepo(repo).RunStdBytes(ctx)
 	if err != nil {
 		return nil, err
 	}
@@ -69,7 +69,7 @@ func (repo *Repository) LsTree(ctx context.Context, ref string, filenames ...str
 func (repo *Repository) GetTreePathLatestCommit(ctx context.Context, refName, treePath string) (*Commit, error) {
 	stdout, _, err := gitcmd.NewCommand("rev-list", "-1").
 		AddDynamicArguments(refName).AddDashesAndList(treePath).
-		WithDir(repo.Path).
+		WithRepo(repo).
 		RunStdString(ctx)
 	if err != nil {
 		return nil, err
--- a/modules/git/tree_nogogit.go
+++ b/modules/git/tree_nogogit.go
@@ -61,7 +61,7 @@ func (t *Tree) ListEntries(ctx context.Context, gitRepo *Repository) (Entries, e
 		return nil, err
 	}

-	stdout, _, runErr := gitcmd.NewCommand("ls-tree", "-l").AddDynamicArguments(t.ID.String()).WithDir(gitRepo.Path).RunStdBytes(ctx)
+	stdout, _, runErr := gitcmd.NewCommand("ls-tree", "-l").AddDynamicArguments(t.ID.String()).WithRepo(gitRepo).RunStdBytes(ctx)
 	if runErr != nil {
 		if gitcmd.IsStderr(runErr, gitcmd.StderrNotValidObjectName) || gitcmd.IsStderr(runErr, gitcmd.StderrNotTreeObject) {
 			return nil, ErrNotExist{
@@ -85,7 +85,7 @@ func (t *Tree) listEntriesRecursive(ctx context.Context, gitRepo *Repository, ex
 	stdout, _, runErr := gitcmd.NewCommand("ls-tree", "-t", "-r").
 		AddArguments(extraArgs...).
 		AddDynamicArguments(t.ID.String()).
-		WithDir(gitRepo.Path).
+		WithRepo(gitRepo).
 		RunStdBytes(ctx)
 	if runErr != nil {
 		return nil, runErr