Skip to content
CAI
Software that uses CAICheck a score

go-gitea/gitea

49.5

Weak · 13 November 2026

315.9k

lines of production code

Go

with TypeScript

6

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Features

Add Alpine package registry support

Introduces a new Alpine package registry capability, allowing users to store and serve Alpine Linux packages (.apk) through Gitea. This change adds the core repository logic in the \services/packages/alpine\ package, including functions to generate and manage RSA key pairs for signing repository files, build APKINDEX index files for specific branches, repositories, and architectures, and handle the propagation of noarch packages across architecture-specific indexes. It establishes the backend infrastructure required to manage Alpine package metadata and storage.

(repo-wide) · high confidence

Add Arch Linux package registry support

Users can now upload and manage Arch Linux packages in Gitea. This change introduces the core parsing logic for Arch package formats (.pkg.tar.gz, .pkg.tar.xz, .pkg.tar.zst), extracting metadata such as name, version, dependencies, and file lists from the .PKGINFO manifest. It includes validation for package names and versions, bounds on file entry counts to prevent metadata amplification, and tests to ensure correct parsing and error handling.

modules/packages/arch, services/packages/arch · high confidence

Add Arch package registry

Users can now upload and retrieve Arch Linux packages via the API. This change introduces the router and service logic for handling Arch package uploads (including signature verification and duplicate detection) and retrieval of package files and repository metadata.

routers/api/packages/arch · high confidence

Add CSV file rendering support

CSV and TSV files are now rendered as HTML tables in the UI. The renderer automatically detects the delimiter (e.g., comma, semicolon), limits output based on configured maximum file size and row count, and includes a warning with a raw view link if the file exceeds these limits. HTML entities in cell content are escaped to prevent injection.

modules/markup/csv · high confidence

Add Cargo HTTP package registry support

Users can now publish and manage Rust packages via a Cargo-compatible HTTP index. This change introduces the backend logic to build and maintain the Cargo index format, including functions to initialize the index repository, update package entries, and rebuild the index from existing packages. It also implements the specific path-building logic required by the Cargo registry protocol and handles package metadata such as dependencies, features, and yanked status.

services/packages/cargo · high confidence

Add Cloudflare Turnstile CAPTCHA support with proxy-aware verification

Users can now use Cloudflare Turnstile as a CAPTCHA provider. The new module introduces a verification function that calls the Turnstile API, ensuring that requests are routed through the system's configured HTTP proxy when proxy settings are enabled. This includes proper handling of API responses and error codes.

modules/turnstile · high confidence

Add Conan package reference and search capabilities

This change introduces the data access layer for the Conan package registry, adding new files to handle recipe and package reference lookups and search functionality. Users can now query for specific Conan recipe revisions, retrieve package references, and search for recipes by name, version, user, and channel within the package system.

models/packages/conan · high confidence

Add Conan package registry support

This change introduces the initial implementation of a Conan package registry within the \modules/packages/conan\ module. It adds parsers for \conanfile.txt\ and \conaninfo.txt\ formats to extract package metadata (such as author, license, and topics) and build settings, along with validation logic for Conan recipe and package references. Comprehensive unit tests are included to verify the parsing and reference validation logic.

(repo-wide) · high confidence

Add Debian package metadata parsing with strict validation and security hardening

The Debian package module now includes a new metadata parser that validates package names, versions, and architectures against Debian policy rules, and restricts distribution/component names to safe character sets to prevent index corruption. The parser supports multiple compression formats for control archives (gzip, xz, zstd) and handles edge cases like trailing slashes in control file names. Security improvements include bounding the decompressed control archive size to prevent decompression bombs and enforcing single-stanza parsing to prevent crafted control files from injecting malicious entries into the repository index.

modules/packages/debian · high confidence

Add FHS-compliant wrapper script for Gitea

A new shell script at contrib/fhs-compliant-script/gitea is introduced to help run Gitea in a Filesystem Hierarchy Standard (FHS) compliant manner. When placed in /usr/bin, this wrapper redirects the binary to /usr/lib/gitea/gitea, sets the working directory to /var/lib/gitea, and defaults the configuration file to /etc/gitea/app.ini unless explicitly overridden by command-line arguments. It uses exec -a to replace the process image while preserving the original script name, ensuring that Gitea operates with standard system paths out of the box.

contrib/fhs-compliant-script · high confidence

Add Go package registry support

Users can now store and retrieve Go modules via the Gitea API. This change introduces endpoints to list package versions, fetch version metadata, retrieve go.mod content, and download package files, as well as an upload endpoint to publish new Go packages.

routers/api/packages/goproxy · high confidence

Add Go package registry support with metadata parsing

Introduces the Go package registry capability by adding a new \ParsePackage\ function in \modules/packages/goproxy/metadata.go\ that extracts module name, version, and \go.mod\ content from Go module zip archives. The implementation validates that the version string is a valid semver and enforces a 16MB size limit on the \go.mod\ file to prevent resource exhaustion. Corresponding tests in \metadata\_test.go\ verify correct parsing of valid packages, detection of invalid structures, and rejection of malformed version strings.

modules/packages/goproxy · high confidence

Add Have I Been Pwned password breach checking

Users can now have their passwords checked against the Have I Been Pwned database during registration and password changes. This new module integrates with the pwnedpasswords.com API to detect if a chosen password has appeared in known data breaches, returning the number of times it has been compromised. The implementation includes privacy-preserving padding support and safeguards against oversized API responses.

modules/auth/password/pwn · high confidence

Add Helm Chart registry

Introduces a new Helm package registry capability, allowing users to upload Helm charts, download package files, and retrieve the charts index via the API. This change adds the \routers/api/packages/helm/helm.go\ handler which implements the standard Helm repository protocol endpoints (index, download, upload) and integrates with the existing package storage and metadata models.

routers/api/packages/helm · high confidence

Add Helm chart metadata parsing and provenance support

Users can now have Helm chart metadata (Chart.yaml) and provenance files (Chart.yaml.prov) parsed and validated when uploading Helm packages. The new metadata.go file introduces structures for chart metadata, maintainers, and dependencies, along with functions to parse chart archives and clearsigned provenance files, ensuring that required fields like API version, name, and version are present and valid.

modules/packages/helm · high confidence

Add Jupyter Notebook (.ipynb) rendering support

Users can now view Jupyter Notebook files directly in the repository viewer. The new renderer supports nbformat 4+ notebooks, displaying code cells with syntax highlighting, markdown cells, and various output types including plain text, images (PNG, JPEG, SVG), HTML, and LaTeX. It includes security measures such as disabling JavaScript execution, sanitizing HTML output, and stripping dangerous tags from markdown. Large notebooks are truncated to 100 cells with a warning message, and older notebook formats are rejected with an informational prompt.

modules/markup/jupyter · high confidence

Add KaTeX rendering to Markdown

Users can now include mathematical expressions in Markdown documents using standard delimiters: inline math with single dollar signs ($...$) or parentheses (\\(...\\)), and block-level math with double dollar signs ($$...$$) or square brackets (\\\[...\\\]). The new math extension parses these syntaxes and renders them as code blocks with the 'language-math' class, which are subsequently processed by the frontend KaTeX library for visual rendering.

modules/markup/markdown/math · high confidence

Add NuGet package metadata parsing and symbol extraction support

Users can now upload NuGet packages (.nupkg) and symbol packages (.snupkg) to the Gitea package registry. The system parses the .nuspec manifest to extract package metadata (ID, version, authors, dependencies, etc.) and validates the package ID and semantic version. For symbol packages, the system extracts Portable PDB files, validates their magic numbers, and parses their debug headers to associate symbols with the correct package versions.

modules/packages/nuget · high confidence

Add NuGet v2 and v3 API support

The NuGet package registry now supports the NuGet v2 (Atom/OData) and v3 (JSON-based) API protocols, enabling full compatibility with standard NuGet clients like \dotnet\, \nuget.exe\, and IDE integrations. This change introduces endpoints for service index discovery, package search, registration leaf/index queries, and package downloads, along with authentication via the \X-NuGet-ApiKey\ header.

routers/api/packages/nuget · high confidence

Add PAM authentication support

Users can now authenticate against the system using Pluggable Authentication Modules (PAM) when the application is built with the \pam\ build tag. This new module provides a \pam.Auth\ function that interacts with the PAM stack to verify credentials and retrieve the authenticated username, while a corresponding stub ensures the code compiles and fails gracefully on systems where PAM support is not enabled.

modules/auth/pam · high confidence

Add PyPI Simple Repository API page template

A new template for the PyPI Simple Repository API has been added, generating the HTML index page for a package as defined by PEP 503. This page lists all available file versions for a package, including links to the files and optional metadata such as the required Python version, enabling clients to discover and download package distributions.

templates/api/packages/pypi · high confidence

Add RPM package metadata parsing

Users can now have RPM package metadata parsed and stored, including package name, version, license, summary, description, architecture, dependencies (provides, requires, conflicts, obsoletes), file lists, and changelogs. This enables better visibility and management of RPM packages within the registry.

modules/packages/rpm · high confidence

Add RPM registry support

Introduces a new RPM package registry, allowing users to upload, store, and serve RPM packages via the API. The implementation includes support for repository configuration generation, PGP key management for signing, and package upload with optional GPG signing. It also handles repository metadata files and supports grouping RPMs by path.

routers/api/packages/rpm · high confidence

Add RPM registry with metadata generation and package signing

Introduces a new RPM package registry capability within the services layer. The new repository.go implementation handles the creation of repository metadata files (such as primary.xml) and organizes RPMs into groups based on their paths. Additionally, the new sign.go file enables GPG signing of RPM packages and repository metadata using PGP keys, ensuring package integrity and authenticity for consumers.

services/packages/rpm · high confidence

Add Terraform state and lock file support

The Terraform package provider now supports parsing and storing Terraform state files and lock files. Users can upload Terraform artifacts that include state information (serial and lineage) and lock metadata, which are persisted in the package properties for later retrieval or validation.

modules/packages/terraform · high confidence

Add application state persistence via database

Introduces a new app state system in the modules/system package that allows the application to persist and retrieve key-value state items using the database. This includes the StateStore interface, a DBStore implementation for database-backed storage, and a RuntimeState struct to hold runtime-specific data such as the last application path and custom configuration location.

modules/system · high confidence

Add basic database-backed indexer stub

A new basic database-backed indexer implementation has been added to the internal indexer package. This component provides the core interface methods (Init, Ping, Close) required by the indexing system, with Init returning true to indicate the index exists and Ping/Close performing no operations, serving as a foundational placeholder for database-based indexing.

modules/indexer/internal/db · high confidence

Add container blob search and image tag listing capabilities

Introduces new database query logic for the container package registry, enabling efficient searching of container blobs by owner, image name, digest, tag, and repository, as well as retrieving sorted lists of image tags for a specific image. This supports backend operations required for container registry interactions, such as manifest resolution and tag enumeration.

models/packages/container · high confidence

Add git-based code search implementation

A new code search implementation using git grep has been added to the indexer, allowing users to search repository code directly via git commands. This change introduces the \gitgrep\ package with \PerformSearch\ to handle search modes (exact, regex) and \indexSettingToGitGrepPathspecList\ to apply include/exclude patterns from settings, along with corresponding unit tests.

modules/indexer/code/gitgrep · high confidence

Add hCaptcha verification support

The application now supports hCaptcha as a CAPTCHA provider. This change introduces a new module that implements an hCaptcha client to verify user tokens against the hCaptcha API, including specific error handling for issues like missing or invalid secrets and responses. Tests are included to verify the client's behavior using a mock transport.

modules/hcaptcha · high confidence

Add in-place upgrade script for binary Gitea installations

Introduces contrib/upgrade.sh, a new bash script that allows users to upgrade Gitea installed via binary distribution on Linux systemd services. The script handles downloading the new binary, verifying checksums and GPG signatures, creating a database backup, replacing the binary, and restarting the service. It supports environment variables for customization (e.g., giteahome, giteauser) and includes compatibility checks for OpenWrt systems.

contrib · high confidence

Add mCaptcha as a supported captcha provider

Users can now configure and use mCaptcha as an open-source captcha provider. This change introduces the mcaptcha module, which implements a client to verify tokens against an mCaptcha server via its API, and includes tests to validate the verification logic.

modules/mcaptcha · high confidence

Add pure SSH LFS support via git-lfs-transfer adapter

Introduces a new \modules/lfstransfer\ module that implements the \transfer.Backend\ and \transfer.LockBackend\ interfaces from the \github.com/charmbracelet/git-lfs-transfer\ library. This enables Gitea to handle Git LFS operations (batch, download, upload, and locking) directly over SSH by acting as an adapter to Gitea's internal LFS API, replacing the need for external LFS servers or complex HTTP-based SSH workarounds.

modules/lfstransfer · high confidence

Add reCAPTCHA verification module

Introduces a new \modules/recaptcha\ package that provides functionality to verify reCAPTCHA tokens against the Google reCAPTCHA API. This module allows users to integrate reCAPTCHA protection into sign-in, sign-up, and account linking flows by validating responses using a configurable secret and URL, returning success status and specific error codes for troubleshooting.

modules/recaptcha · high confidence

Add repository configuration and linting files

Added several new configuration and linting files to the repository root, including .editorconfig for consistent code formatting, .gitattributes for Git attribute handling, .ignore for build artifacts, .mailmap for author attribution, .markdownlint.yaml for Markdown linting, .shellcheckrc for shell script linting, .spectral.yaml for OpenAPI linting, and .envrc for direnv integration.

(repo-wide) · high confidence

Add rootless Docker image support and unify nightly naming

The Docker build process now generates and publishes rootless variants of the Gitea image (e.g., \gitea/gitea:latest-rootless\), alongside the standard images, supporting linux-amd64, linux-arm64, and linux-riscv64 architectures. Additionally, the nightly image naming convention has been unified across all binaries and Docker images to ensure consistent tagging between release candidates, development builds, and nightly snapshots.

docker · high confidence

Add sitemap generation module

A new \modules/sitemap\ package has been introduced to support generating XML sitemaps and sitemap indexes. This module provides structures and functions to create valid sitemap XML compliant with the sitemaps.org schema, including support for URL entries with optional last modification dates. It enforces limits on the number of URLs (50,000) and file size (50 MB) to prevent excessive memory usage, and includes comprehensive tests for both standard sitemaps and sitemap indexes.

modules/sitemap · high confidence

Add support for Dart Pub package registry

Users can now publish and consume Dart packages via the Pub repository protocol. This change introduces the necessary router handlers and API endpoints to list package versions, retrieve version metadata, and handle package uploads, integrating with the existing package storage and service layer.

routers/api/packages/pub · high confidence

Add support for Pub packages

Users can now store and manage Dart/Flutter Pub packages. This change introduces the \modules/packages/pub\ module, which includes logic to parse \.tar.gz\ Pub package archives, extract \pubspec.yaml\ metadata (such as name, version, description, and URLs), and read the README file. It also adds corresponding unit tests to validate the parsing logic for valid, invalid, and edge-case package structures.

modules/packages/pub, modules/packages/vagrant · high confidence

Add support for rendering terminal output with colors

Users can now view terminal/console output with preserved ANSI color codes in markup. A new renderer detects files matching \\*.sh-session\ and converts terminal escape sequences into styled HTML using the \terminal-to-html\ library, allowing colored command-line logs to be displayed correctly in the UI.

modules/markup/console · high confidence

Add template variable expansion utilities

The \modules/templates/vars\ package now provides two functions for expanding variables in template strings: \ExpandCurlyBrace\, which replaces \{var}\ placeholders with values from a map (returning errors for syntax issues or missing keys), and \ExpandShellLike\, which expands \$var\ and \${var}\ style placeholders while preserving non-existent variables. These utilities enable consistent variable substitution in template rendering across the application.

modules/templates/vars · high confidence

Added RPM group search capability

A new search function for RPM packages has been introduced, allowing users to retrieve all available package groups for a specific owner. This is implemented via the new \GetGroups\ function in the RPM package model, which queries distinct property values to list groups associated with the specified owner ID.

models/packages/rpm · high confidence

Added advanced GitHub label definitions

A new file defining a comprehensive set of GitHub labels has been added to the project's contribution options. This includes standardized labels for issue status (e.g., Needs feedback, In progress, Completed), issue kind (e.g., Bug, Security, Feature), review status (e.g., Confirmed, Wontfix), and priority levels (e.g., High, Critical), each associated with specific hex color codes to improve issue tracking and triage consistency.

contrib/options · high confidence

Added graceful shutdown coordination for release/reopen operations

A new \releasereopen\ module has been introduced to manage the lifecycle of release and reopen actions during graceful shutdowns. It provides a \Manager\ that allows components to register \ReleaseReopener\ instances, ensuring that all registered operations are executed in sequence when the system shuts down, with proper cancellation support for individual registrations.

modules/graceful/releasereopen · high confidence

This change introduces new contributor resources to help operators deploy and maintain Gitea. It adds sample Privacy Policy and Terms of Service HTML templates in contrib/sample-page for legal compliance customization. Additionally, it provides init scripts and service definitions for several operating systems: FreeBSD rc.d, Gentoo OpenRC, macOS launchd, OpenBSD rc.d, and OpenWrt procd, enabling easier system integration for these platforms.

contrib/grafana-monitoring-mixin, contrib/sample-page, contrib/service · high confidence

Automated cleanup of package versions and expired data

A new cleanup service has been introduced to automatically manage package storage by executing defined cleanup rules and removing expired data. This service handles version deletion based on configurable criteria such as age, count, and pattern matching for various package types including Container, Cargo, Debian, Alpine, RPM, and Arch. When versions are removed, the service ensures that associated repository index files are rebuilt for Debian, Alpine, RPM, and Arch packages, and updates the Cargo package index, ensuring that the package registries remain consistent and up-to-date after cleanup operations.

services/packages/cleanup · high confidence

CITATION.cff files are now rendered as APA and BibTeX citations

The system now parses CITATION.cff files and generates standardized APA and BibTeX citation strings for software and other research outputs. This new capability allows users to obtain machine-readable and human-readable citations directly from their repository's citation metadata, supporting various citation types such as software, journal articles, conference papers, and theses.

modules/citation · high confidence

CLI commands for managing authentication sources and Actions runner tokens

Administrators can now configure external authentication sources (LDAP and OAuth2) and generate Actions runner tokens directly from the command line. The new \gitea admin auth\ subcommands allow adding, updating, and listing LDAP (Bind DN and Simple Auth) and OAuth2 sources with full flag support for settings like scopes, claim mapping, and team synchronization. Additionally, a new \gitea actions generate-runner-token\ command enables the creation of registration tokens for Actions runners, scoped to a specific owner or repository.

cmd · high confidence

Commit author stacks now include co-authors

The commit view now displays an avatar stack that includes not only the primary commit author but also any co-authors listed in the commit message. This change updates the underlying data model to aggregate all author identities, matching them to Gitea users where possible, so that users can see the full list of contributors at a glance rather than just the single author.

models/gituser · high confidence

Composer package metadata parsing and archive support

The Composer package module now extracts richer metadata from \composer.json\, including description, readme, comments, keywords, homepage, license, authors, and the \bin\ field. It also supports parsing packages compressed as \.zip\, \.tar.gz\, and \.tar.bz2\, with improved validation using \ErrInvalidArgument\ for missing or invalid package files.

modules/packages/composer · high confidence

Debian package registry support

Users can now publish and consume Debian packages through Gitea. This change introduces the core service logic for managing Debian repositories, including the generation of strong PGP signing keys (RSA 4096, SHA-256, AES-256) and the automatic building of repository index files (Packages, Release) in various compression formats. It also adds a user-facing setup manual that provides copy-pasteable commands for configuring APT sources to use the new registry.

routers/api/packages/swift, services/packages/debian · high confidence

Debian package search and metadata retrieval capabilities

Users can now search for Debian packages and retrieve available distributions, components, and architectures. This change introduces the search logic and metadata queries for the Debian package registry, enabling filtering by owner, distribution, component, and architecture properties.

models/packages/debian · high confidence

Implement NuGet package search functionality

Added a new search implementation for NuGet packages, introducing functions to retrieve package versions and count packages based on search options. This enables users to search for NuGet packages within the system, supporting features like exact name matching, internal package filtering, and pagination.

models/packages/nuget · high confidence

Initial support for Alpine Linux package registry

This change introduces the Alpine package registry, allowing users to upload and serve Alpine Linux packages (.apk files) through Gitea. The implementation includes endpoints for retrieving repository signing keys, serving package index files (with fallback to noarch indices for universal packages), and uploading new packages with proper metadata handling and duplicate detection.

routers/api/packages/alpine · high confidence

Initial support for PyPI package registry

Users can now upload, download, and browse Python packages via the PyPI-compatible API. The implementation validates package names and versions according to PEP 426 and PEP 440, normalizes names, and extracts the project homepage from the \Project-URL\ metadata field (falling back to the deprecated \Home-page\ field). Package listings are sorted by version to mimic standard PyPI behavior, and uploads require a matching SHA-256 digest for integrity verification.

routers/api/packages/maven, routers/api/packages/pypi · high confidence

Introduce Azure Blob Storage support

Users can now store Gitea data (attachments, LFS, avatars, packages, actions) on Microsoft Azure Blob Storage. This adds a new \AzureBlobStorageType\ alongside the existing Local and MinIO (S3-compatible) backends, allowing configuration of an Azure endpoint, account key, container, and base path. The implementation uses a custom REST client for Azure authentication and includes full test coverage for read/write, seek, and direct URL generation.

modules/storage · high confidence

Introduce Cargo package registry support

Users can now publish and download Rust packages via the Cargo registry protocol. This change adds the necessary HTTP endpoints to handle package indexing, searching, version enumeration, owner management, and file uploads/downloads, integrating with the existing package storage and service layers.

routers/api/packages/cargo · high confidence

Introduce Gitea-specific performance tracing module

Added a new \modules/gtprof\ package that provides a framework for recording performance traces within Gitea. This includes a \Tracer\ for managing trace spans and events, a built-in tracer that logs slow operations to the message recorder when they exceed a configurable threshold, and constants for standard trace attributes (e.g., HTTP routes, SQL queries). This module enables developers to instrument code for performance analysis and debugging.

modules/gtprof · high confidence

Introduce HTMLBuilder and HTMLWriter utilities for safe HTML generation

The \modules/htmlutil\ package now provides \HTMLBuilder\ and \HTMLWriter\ interfaces along with helper functions like \HTMLFormat\ and \EscapeString\. These tools allow the application to construct HTML content programmatically while automatically escaping untrusted strings to prevent injection issues, ensuring that raw HTML is only written when explicitly marked as safe.

modules/htmlutil · high confidence

Introduce Material Icon theme for file icons

The file icon system now supports a Material Icon theme alongside the existing basic Octicons. Users can configure the file icon theme via the \UI.FileIconTheme\ setting and the folder icon theme via the new \UI.FolderIconTheme\ setting, allowing folders and symlinks to directories to use a different theme than regular files. The Material provider loads icon rules and SVGs from embedded JSON assets, mapping files by name, extension, or language ID, while maintaining backward compatibility by preserving Octicon class names for theme plugins.

modules/fileicon · high confidence

Introduce Meilisearch as an issue indexer backend

A new Meilisearch-based indexer for issues has been added, allowing users to search and filter issues using Meilisearch. The implementation supports filtering by repository, public/private status, pull request status, closed/archived state, labels, milestones, projects, and various user roles (poster, assignee, mention, review, subscriber). It also supports sorting by update/create time, deadline, comment count, and ID, with pagination limited to 10,000 total hits. The indexer configures ranking rules to prioritize sort order and supports exact word search modes. Tests verify indexing, search result conversion, and keyword handling.

modules/indexer/issues/meilisearch · high confidence

Introduce Meilisearch indexer with filtering and paging support

Added a new Meilisearch-based indexer implementation in the \modules/indexer/internal/meilisearch\ package, enabling users to search, filter, and page through indexed content using Meilisearch. The implementation includes a filter system supporting AND/OR combinations, equality, inclusion, and range checks, along with versioned index management and health checks.

modules/indexer/internal/meilisearch · high confidence

Introduce Org mode markup rendering

Users can now render .org files directly in the repository view. This change adds a new renderer that converts Org mode syntax to HTML, supporting standard links, internal file links, media (images and videos), and source code blocks with syntax highlighting via Chroma. It also handles include directives by rendering them as text and includes safeguards to prevent panics during code block highlighting.

modules/markup/orgmode · high confidence

Introduce OwnerType enum for consistent entity classification

A new \OwnerType\ type has been added to the shared models package to standardize how different owner entities (system-global, individual, repository, organization) are identified and localized across the application. This change provides a structured way to handle owner classification logic, ensuring consistent translation and display of owner concepts in the UI and API.

models/shared · high confidence

Introduce Prometheus metrics collector with granular issue and user state tracking

The \modules/metrics\ package now exposes a comprehensive Prometheus collector (\collector.go\) that provides detailed operational metrics for Gitea. This includes build information, counts for core entities like repositories, users, and issues, and specifically breaks down issues into open and closed states as well as by label and repository. Additionally, the \gitea\_users\ metric now includes a 'state' label to distinguish user statuses, and project board columns are exposed as a distinct metric.

modules/metrics · high confidence

Introduce SVG badge generation module for Actions

The \modules/badge\ package has been added to provide the core logic for generating SVG badges, specifically for GitHub Actions status indicators. This new module implements the layout engine (calculating text widths and positioning for labels and messages) and defines the visual style constants, including support for 'flat' and 'flat-square' styles as well as color mappings for various action statuses (success, failure, skipped, etc.). This change establishes the foundational component for rendering action status badges, moving the implementation from ad-hoc code into a dedicated, reusable module.

modules/badge · high confidence

Introduce WebAuthn module for passkey authentication

A new WebAuthn module has been added to handle passkey-based authentication. This change introduces the core initialization logic and user credential management required for WebAuthn support, including registering the session data for serialization and configuring the WebAuthn instance with application settings. Tests have been added to verify the correct initialization of the WebAuthn configuration.

modules/auth/webauthn · high confidence

Introduce built-in identicon avatar generator

The system now includes a built-in identicon generator that creates unique, pseudo-random geometric avatars from user data (such as email or IP address). This new module, located in modules/avatar/identicon, implements a deterministic algorithm using SHA-256 hashing to select from a defined set of geometric blocks and a curated palette of dark colors, ensuring consistent and visually distinct icons for users without uploaded profile pictures.

modules/avatar/identicon · high confidence

Introduce centralized proxy configuration module

A new proxy module has been added to centralize proxy handling, providing functions to retrieve the configured proxy URL, determine if a specific host should be proxied based on configured patterns, and return an HTTP proxy function that respects both explicit proxy settings and environment variables. It also includes a utility to inject proxy environment variables into process environments for URLs that require proxying.

modules/proxy · high confidence

Introduce centralized secret and SSH key generation module

A new \modules/generate\ package has been added to provide a unified interface for creating cryptographic secrets and keys. This module introduces functions to generate internal tokens and JWT secrets (using \golang-jwt/jwt/v5\), create random secret keys, and generate SSH keys in RSA, ECDSA, and ED25519 formats. It also includes constants for minimum and default key bit sizes, ensuring consistent security standards across the application.

modules/generate · high confidence

Introduce dedicated paginator module for UI pagination logic

A new \modules/paginator\ package has been added to centralize pagination calculations. This module provides a \Paginator\ struct and associated methods (such as \IsFirst\, \HasPrevious\, \Pages\, etc.) that compute page ranges, handle unlimited paging scenarios, and generate the list of page numbers to display in templates. This change extracts pagination logic from various parts of the codebase into a reusable component, ensuring consistent behavior for pagination UI elements across the application.

modules/paginator · high confidence

Introduce distributed global locking module

A new \modules/globallock\ package provides a unified locking interface that supports both in-memory and Redis-backed distributed locks. This allows Gitea instances running in a cluster to coordinate access to shared resources, replacing the previous single-instance exclusive pool mechanism. Users can now acquire locks via \Lock\, \TryLock\, or the convenience \LockAndDo\/\TryLockAndDo\ functions, with the backend determined by the \GlobalLock.ServiceType\ setting (defaulting to memory).

modules/globallock · high confidence

Introduce egress policy enforcement for migrations, webhooks, and security requests

This change introduces a new egress policy system in the \modules/egress\ package that controls outbound network connections for migrations, webhooks, and security-related requests. The system supports 'lax' and 'strict' modes, allowing administrators to define allow and block lists for hostnames and IP ranges (including CIDRs and named ranges like 'private' and 'loopback'). It enforces that restricted addresses (private, loopback, link-local, CGNAT) require explicit IP-based allow entries when \localNeedsIPAllow\ is enabled, and ensures that reserved addresses are always denied. The implementation includes specific proxy handling for git operations (respecting \http.proxy\ config) and webhooks, ensuring that traffic routed through proxies is exempt from the egress lists while still validating the proxy's own connectivity.

modules/egress · high confidence

Introduce file-backed buffer for large data handling

A new \FileBackedBuffer\ utility has been added to the \modules/util/filebuffer\ package, allowing applications to handle data streams that exceed a specified memory threshold by automatically spilling excess content to a temporary file. This component implements standard I/O interfaces (\io.ReadWriteCloser\, \io.ReadSeekCloser\, \io.ReaderAt\), enabling seamless integration for operations like package uploads where data size may vary, ensuring memory efficiency while maintaining read/write capabilities.

modules/util/filebuffer · high confidence

Introduce localized relative time formatting and nano-timestamp utilities

The \modules/timeutil\ package now provides a new \timeSincePro\ function that generates localized, human-readable relative time strings (e.g., "1 hour, 2 minutes") by leveraging the translation locale, replacing previous display logic. It also includes \MinutesToFriendly\ for converting minute counts into these formatted strings and \TimeStampNano\ for handling nanosecond-precision timestamps with locale-aware conversion.

modules/timeutil · high confidence

Introduce new modular Git LFS client and storage implementation

The \modules/lfs\ package has been rewritten to provide a structured, modular Git LFS implementation. This change introduces a new \Client\ interface with dedicated \HTTPClient\ and \FilesystemClient\ implementations, enabling LFS operations over HTTP or local filesystems. It adds a \ContentStore\ that validates object integrity by verifying SHA256 hashes and file sizes during storage, and includes an \Endpoint\ resolver that automatically derives LFS URLs from clone URLs or accepts explicit configurations. The update also adds a \PointerScanner\ for efficiently identifying LFS pointer blobs in repositories and includes comprehensive tests for the new client, endpoint resolution, and pointer parsing logic.

modules/lfs · high confidence

Introduce rootless Docker image with environment-based configuration

The rootless Docker image now includes entrypoint and setup scripts that automatically generate the Gitea configuration file from environment variables if it does not already exist, allowing users to configure the instance via environment variables rather than manual file edits. A new \environment-to-ini\ helper script enables runtime updates to the INI config using the \config edit-ini\ command, and the entrypoint validates the Docker version to ensure compatibility with newer Alpine releases.

docker/rootless/usr · high confidence

Introduce secret encryption module for database values

A new \modules/secret\ package has been added to provide AES-based encryption and decryption for sensitive data, such as database values. This module exposes \EncryptSecret\ and \DecryptSecret\ functions that hash a provided key using SHA-256 and encrypt/decrypt strings using AES in CFB mode, returning results as hex-encoded strings. The implementation includes specific error handling for invalid hex inputs and incorrect keys, with tests verifying correct encryption/decryption cycles and error propagation for malformed inputs.

modules/secret · high confidence

Introduce snap packaging for Gitea

This change adds the necessary files to build and distribute Gitea as a Snap package. It includes a \snapcraft.yaml\ configuration that defines the application structure, sets strict confinement, and specifies build dependencies on Go 1.26 and Node 24. Two new shell scripts, \part-gitea-pull.sh\ and \part-gitea-build.sh\, implement the build logic: the pull script automatically checks out the latest stable release tag if available, otherwise building from the current branch, while the build script compiles the binary with specific build tags and installs it into the snap package.

snap · high confidence

Introduce structured YAML-based issue templates with validation

The \modules/issue/template\ package now supports parsing and validating issue templates defined in YAML format, in addition to the existing Markdown support. This change adds a new \template.go\ file containing validation logic for template metadata (name, about) and form fields (input, textarea, dropdown, checkboxes, markdown), ensuring required attributes, unique IDs, and correct data types. The \unmarshal.go\ file handles reading templates from Git repositories and unmarshalling YAML content, including compatibility for the \description\ field as \about\. Tests in \template\_test.go\ verify these validation rules. This enables users to define complex issue forms with dropdowns, checkboxes, and inputs using a structured YAML schema.

modules/issue · high confidence

Introduce structured parser for git for-each-ref output

Added a new \foreachref\ package that provides a structured way to parse the output of \git for-each-ref\. This includes a \Format\ type to define output fields and delimiters, and a \Parser\ that reads the raw output into typed maps of key-value pairs. The parser is configured to handle large reference contents by increasing the buffer size to 4MB, ensuring robustness for tags or refs with long messages.

modules/git/foreachref · high confidence

Introduction of search mode configuration types

The indexer module now defines the core data structures for search modes, including \SearchModeType\ and \SearchMode\, along with helper functions to retrieve specific combinations of search behaviors (exact, words, fuzzy, and regexp). This establishes the foundational type definitions and available options for search functionality within the indexer.

modules/indexer · high confidence

Label templates now support YAML format and validate colors

The label module now accepts YAML-based label template files (in addition to the legacy format), allowing users to define labels with structured fields like name, color, description, and exclusive priority. Color values are validated and normalized to 6-character hex codes during template loading, ensuring consistent display. This change also introduces support for exclusive labels with ordering, enabling priority-based sorting for issues.

modules/label · high confidence

New CSV module with automatic delimiter detection and flexible parsing

A new \modules/csv\ package has been introduced to handle CSV file rendering and parsing. This module automatically detects the field delimiter (comma, tab, semicolon, pipe, or @) by analyzing file content and extensions (e.g., \.tsv\ for tabs), ensuring correct display of various CSV formats. It disables strict field count validation to accommodate rows with varying numbers of columns, preventing render errors on malformed or irregular CSV data. The implementation includes robust guessing logic that prioritizes delimiters found near quoted strings and handles edge cases like leading spaces and empty fields.

modules/csv · high confidence

New Elasticsearch code indexer implementation

A new Elasticsearch-based code indexer has been introduced in the \modules/indexer/code/elasticsearch\ package. This implementation defines a specific index mapping with custom analyzers for content and file paths, and handles indexing logic such as excluding vendored files and managing file size limits. The change also includes initial test coverage for internal indexing utilities.

modules/indexer/code/elasticsearch · high confidence

New Git attribute parsing module for language detection

A new \modules/git/attribute\ package has been introduced to parse Git attributes (such as \linguist-vendored\, \linguist-language\, and \gitlab-language\) using \git check-attr\. This module provides both batch and single-check capabilities to determine file properties like language, vendored status, and documentation flags, which are essential for accurate syntax highlighting and repository language statistics.

modules/git/attribute · high confidence

New Git pipeline utilities for LFS and object processing

The \modules/git/pipeline\ package now provides new functions to handle Git operations via piped commands, including \FindLFSFile\ to locate commits containing specific LFS pointer hashes, \CatFileBatch\ variants for efficient batch object inspection, and \RevListObjects\ to list blobs between commits. These utilities replace direct command execution with structured pipeline handling, improving performance and context propagation for large repository scans.

modules/git/pipeline · high confidence

New HTTP authorization header parser module

A new \httpauth\ module has been added to parse HTTP Authorization headers, supporting both Basic authentication (username/password) and Bearer/Token authentication. The \ParseAuthorizationHeader\ function extracts credentials from the header string, handling case-insensitive scheme matching and validating the base64-encoded Basic auth payload. This provides a standardized way to interpret authorization headers across the application.

modules/auth/httpauth · high confidence

New HTTP caching module with ETag and Last-Modified support

A new \modules/httpcache\ package has been introduced to standardize HTTP caching behavior across the application. It provides utilities to set Cache-Control headers (supporting public/private scopes and max-age) and handles conditional requests via ETag and Last-Modified headers. The module supports weak ETag validation, allowing clients to use weak validators to match strong response validators, and returns 304 Not Modified when appropriate, improving cache efficiency for static assets and API responses.

modules/httpcache · high confidence

New URI module with SSRF-safe client support

A new \modules/uri\ package has been introduced to centralize URI opening logic, supporting both local files and remote HTTP/HTTPS URLs. The key behavioral change is the addition of \OpenWithClient\, which allows callers to provide a custom HTTP client. This enables strict SSRF (Server-Side Request Forgery) protection by allowing the application to validate or block redirects to internal addresses, whereas the previous default \Open\ function used \http.DefaultClient\ and followed redirects blindly.

modules/uri · high confidence

New build tools for OpenAPI 3.0 generation and asset management

The build process now includes new Go-based scripts to generate bindata, emoji data (supporting Unicode 16 and skin tones), gitignore files, and Go module licenses. A key addition is the OpenAPI 3.0 generator, which converts the existing Swagger 2.0 spec into OAS 3.0, extracting shared enums into named schemas and fixing file/URI formats for better SDK compatibility. The locale update script has also been rewritten to handle JSON locale files.

build · high confidence

New container utilities for filtering and sets

The container module now includes a new \FilterSlice\ function that filters and deduplicates slices using a generic predicate, along with a \Set\ type supporting add, remove, and containment checks. These additions provide reusable, type-safe helpers for common data manipulation tasks within the application.

modules/container · high confidence

New database installation utility functions

A new \models/db/install\ package has been added to centralize database-related checks during the installation process. This includes functions to verify database connectivity, retrieve the current migration version, and determine if post-installation users exist, all utilizing the standard database engine context.

models/db/install · high confidence

New database-backed session provider and session ID regeneration

The session module now supports storing session data in the application database via a new \db\ provider, allowing sessions to persist across application restarts and scale horizontally without relying solely on file or memory storage. Additionally, session IDs are now regenerated upon login to prevent session fixation attacks, ensuring that a session ID obtained before authentication is never used for authenticated access.

modules/session · high confidence

New database-based issue indexer implementation

A new database-backed issue indexer has been added to replace or supplement existing search mechanisms, enabling issue searches and filtering directly via the database using LIKE queries. This implementation supports searching by keyword in issue titles, content, and comments, as well as filtering by assignee, labels, milestones, project, archive status, and closed/open state. It also provides sorting by creation date, update date, comment count, and deadline, and handles pagination and total count retrieval for issue lists.

modules/indexer/issues/db · high confidence

New generic optional type with JSON and YAML serialization support

The \modules/optional\ package introduces a new generic \Option\[T\]\ type to represent values that may or may not be present, replacing the previous \util.OptionalBool\ pattern with a more flexible, type-safe alternative. This type supports serialization to and from JSON and YAML formats, allowing optional fields to be correctly marshaled as \null\ when empty and unmarshaled from \null\ or missing keys, while also providing utility functions like \ParseBool\ for string-to-optional-bool conversion.

modules/optional · high confidence

A new \modules/git/url\ package has been introduced to standardize the handling of Git URLs. It provides \ParseGitURL\ to correctly parse various Git URL formats, including HTTP(S), SSH, SCP-style short syntax, and file paths, with specific support for IPv6 addresses in brackets. The module also includes \ParseRepositoryURL\ to extract owner and repository names from URLs belonging to the current Gitea instance, and \MakeRepositoryWebLink\ to generate corresponding HTTP/HTTPS web links for repositories, ensuring that internal links do not leak local addresses.

modules/git/url · high confidence

New language statistics module for Git repositories

A new \modules/git/languagestats\ package has been added to calculate language usage statistics for Git repositories. This module leverages the \go-enry\ library and Git attributes (such as \.gitattributes\ linguist settings) to detect and group programming languages, handling case-insensitive merging of language names and respecting filters for vendored, generated, or documentation files. It provides a \GetLanguageStats\ function that efficiently processes repository trees using Git's \cat-file\ batch commands to compute byte counts per language.

modules/git/languagestats · high confidence

A new \mdstripper\ module has been added to extract plain text from Markdown content while collecting all links. It uses the Goldmark parser to remove all markup and code blocks, returning the stripped text and a list of collected links. The module specifically handles local issue and pull request references (e.g., \/user/repo/issues/3\), converting them into a compact format (e.g., \user/repo\#3\) in the output text, while other links are collected separately.

modules/markup/mdstripper · high confidence

New npm package registry module implementation

This change introduces the core logic for the new npm package registry within the \modules/packages/npm\ directory. It adds the \creator.go\ file, which defines the data structures for parsing npm package metadata (including versions, dependencies, and distribution details) and handling package uploads, along with \metadata.go\ for storing package-specific metadata. A corresponding test file (\creator\_test.go\) is added to validate package name formats, version constraints, and integrity checks. This module serves as the foundational backend component for the npm registry feature.

modules/packages/npm · high confidence

New package storage, hashing, and validation infrastructure

This change introduces core infrastructure for the package registry within the modules/packages area. It adds a ContentStore to manage blob storage and direct serving URLs, a BoundedFileList to enforce limits on archive file counts and name lengths, and a HashedBuffer/MultiHasher system to compute MD5, SHA1, SHA256, and SHA512 checksums while buffering data. It also includes a PyPI metadata structure and corresponding unit tests for the hashing logic.

modules/packages · high confidence

New password validation and generation module

A new \modules/auth/password\ package has been introduced to centralize password handling. This module provides configurable complexity checks (supporting lowercase, uppercase, digits, and special characters) and integrates with the Have-I-Been-Pwned API to detect compromised passwords. It also includes a secure random password generator that respects both complexity rules and pwned-password checks, along with localized error reporting for users.

modules/auth/password · high confidence

New pprof profiling module for CPU and memory dumps

A new \modules/pprof\ package has been introduced, providing functions to start CPU profiling and write heap (memory) profiles to temporary files. This allows the application to capture performance data for specific contexts, with the \DumpPprofForUsername\ function handling the setup, execution, and cleanup (stopping the profile and writing the memory dump) in a single callable unit.

modules/pprof · high confidence

New process management module with hierarchical tracking and graceful command execution

The \modules/process\ package introduces a centralized process manager that tracks internal Gitea operations as a hierarchical tree of contexts, allowing users to view parent-child relationships and stack traces of running processes in the admin monitor. It also provides a new \CommandContext\ wrapper for external commands that ensures entire process groups are killed (using SIGTERM or SIGKILL) when the parent context is canceled, preventing zombie processes and data corruption during cancellations.

modules/process · high confidence

New reference parsing module for issues, commits, and mentions

The \modules/references\ package has been introduced to centralize the parsing of cross-references in text. It now handles numeric and alphanumeric issue references (e.g., \\#123\, \ABC-123\), cross-repository references (e.g., \owner/repo\#123\), commit SHA references (e.g., \owner/repo@sha\), and user/team mentions (e.g., \@user\, \@org/team\). The module also supports detecting close/reopen keywords (like \closes\ or \reopens\) and time-tracking logs, providing structured data for these elements to be rendered or acted upon by the rest of the application.

modules/references · high confidence

New regex compilation cache module

A new \modules/regexplru\ package has been added to provide an LRU-based cache for compiled regular expressions. This module introduces \UserCache\ and \SystemCache\ instances that store compiled regex patterns and their associated errors, allowing repeated use of the same pattern without re-compilation overhead. The implementation uses the \hashicorp/golang-lru/v2\ library and includes tests to verify caching behavior and error handling.

modules/regexplru · high confidence

A new \models/renderhelper\ package has been introduced to centralize the creation of markup rendering contexts and the resolution of relative links. It provides specialized helpers—\RepoComment\, \RepoFile\, \RepoWiki\, and \SimpleDocument\—that correctly resolve links (such as images, code references, and issue numbers) relative to the current repository, branch, or tree path. The package also includes a \commitChecker\ to efficiently validate commit IDs and ensures that rendered HTML includes generated IDs for headings.

models/renderhelper · high confidence

New repository module with branch, commit, and fork utilities

The \modules/repository\ package now provides core repository management utilities, including \SyncRepoBranches\ to synchronize the database branch table with the Git repository (updating the object format name and handling additions, updates, and deletions), \PushCommit\ and \PushCommits\ helpers to transform Git commits into API payload formats, and \CanUserForkRepo\ to enforce forking permissions. The module also includes \UpdateRepoSize\ for calculating repository sizes, \PushingEnvironment\ for setting up Git hook environment variables, and \GetLicense\ for filling license placeholders with repository metadata.

modules/repository · high confidence

New rotating file writer utility with compression and retry support

A new \rotatingfilewriter\ package has been introduced to handle log file rotation, allowing users to configure size-based or daily rotation, retention periods, and optional gzip compression of old log files. The implementation includes robustness improvements such as retrying file rename operations when files are busy and integrating with the graceful shutdown manager to ensure file handles are correctly released and reopened.

modules/util/rotatingfilewriter · high confidence

New router request logging and slow-query detection

The routing module now includes a dedicated request logger that records HTTP request lifecycle events, including start, completion, and panics. It automatically detects slow requests (defaulting to a 3-second threshold) and logs them with a 'still-executing' status, while also distinguishing long-polling requests to adjust log verbosity. This provides developers with detailed, structured logs for debugging router performance and request handling.

modules/web/routing · high confidence

New test logger module for structured test output

A new \modules/testlogger\ package has been introduced to standardize how test logs are captured and displayed. This module registers a custom log writer that routes log messages directly to the Go testing framework's output, ensuring logs are associated with the correct test case. It includes functionality to print the current test name and file location, handle test timeouts and slow flushes with specific markers, and manage queue flushing at the end of each test to prevent data loss or hanging. This provides a more structured and reliable logging experience during test execution.

modules/testlogger · high confidence

New utility functions for byte sizes, file operations, and error handling

The modules/util package introduces several new capabilities: FormatByteSize and ParseByteSize for human-readable byte size formatting and parsing; retry logic for file removal and renaming to handle busy files on Windows; a new error system with translatable errors and HTTP status code mapping; color utility functions for contrast calculation and text color selection; and path joining helpers that safely handle relative and absolute paths across operating systems.

modules/util · high confidence

New zstd module with seekable compression support

A new \modules/zstd\ package has been introduced, providing a high-level API for reading and writing zstd-compressed data, including support for seekable zstd streams. This module wraps the \klauspost/compress/zstd\ and \SaveTheRbtz/zstd-seekable-format-go\ libraries, exposing encoder/decoder options and enforcing a default maximum window size of 128 MiB to limit memory usage. The addition includes comprehensive tests for both standard and seekable read/write operations.

modules/zstd · high confidence

Scoped template execution with context-aware function maps

The template rendering system now supports scoped template sets that allow different function maps to be applied during execution. This enables context-specific template functions (such as request-scoped helpers) to be used safely and concurrently, while ensuring HTML escaping is enforced at parse time to prevent injection vulnerabilities. Users benefit from more flexible and secure template rendering where context-dependent logic can be injected without affecting other concurrent requests.

modules/templates/scopedtmpl · high confidence

Support for Maven POM metadata parsing with parent inheritance and encoding

The system can now parse Maven package metadata from POM files, extracting group ID, artifact ID, name, description, URL, licenses, and dependencies. This update handles non-UTF-8 encodings (such as ISO-8859-1) and correctly resolves group IDs inherited from parent POMs, ensuring accurate package identification even in multi-module projects.

modules/packages/maven · high confidence

Support for OCI and Helm container image metadata parsing

The container package now includes logic to parse and extract metadata from both OCI/Docker and Helm chart images. Users can now view detailed information such as platform, description, authors, licenses, and project URLs for container images, as well as chart-specific details like maintainer names and source repositories for Helm charts. This enhancement improves the visibility and usability of container packages within the registry.

modules/packages/container · high confidence

Support for frontend-based rendering of 3D models and OpenAPI specs

The external markup module now includes built-in support for rendering OpenAPI/Swagger specifications and 3D model files (such as .glb, .gltf, .stl, and .obj) directly in the browser via an iframe-based frontend renderer. This change introduces new file pattern handlers for these formats, allowing users to view these complex file types natively within the application without requiring external server-side tools, while maintaining the existing capability to configure and use custom external command-line renderers.

modules/markup/external · high confidence

Swift Package Registry support with manifest parsing and metadata handling

Users can now upload and browse Swift packages via the new Swift Package Registry. This change introduces the core parsing logic for Swift package archives, including support for multiple manifest files (e.g., \Package.swift\ and version-specific variants like \[e-mail redacted]\) while correctly ignoring nested manifests in subdirectories. It also extracts and exposes package metadata such as description, keywords, license, repository URL, and author information in the API response, enabling better discoverability and integration with Swift tooling.

modules/packages/swift · high confidence

Architecture

Centralized API struct definitions in modules/structs

The API request and response models have been consolidated into the \modules/structs\ package. This change introduces dedicated Go structs for core API resources, including webhooks (\hook.go\), issues and pull requests (\issue.go\, \issue\_comment.go\), labels, milestones, attachments, notifications, and user administration (\admin\_user.go\). By defining these types in a shared module, the codebase ensures consistent JSON serialization and Swagger documentation across all API endpoints, while also including validation helpers and payload parsers for webhook events.

modules/structs · high confidence

Database migration framework restructured into isolated package

The database migration logic has been refactored into a dedicated \modelmigration\ package, separating it from the core models to prevent future model changes from breaking existing migrations. This change introduces a new \base\ sub-package containing shared migration utilities (such as table recreation and column dropping) and a test harness (\migrationtest\) that automatically loads YAML fixtures from \modelmigration/fixtures\ for validation. The migration versioning system has also been updated, with the expected database version now calculated as 72. Also in this area: 1 commit (1 fix) fixing gitea.dev, modelmigration; Protected branch settings migrated to JSON and deploy-key handling modernized; Database schema updates for authentication tokens and action task steps.

modelmigration · medium confidence · unverified

Migrate router framework from Macaron to go-chi

The internal HTTP routing layer has been replaced with go-chi, moving away from the legacy Macaron framework. This architectural change modernizes the request handling infrastructure, providing a more standard and maintainable routing system for all API and web endpoints.

routers · high confidence

New modular configuration system for Actions, Admin, API, Attachments, and Audit settings

The \modules/setting\ package has been refactored to split configuration loading into dedicated, modular files. This introduces explicit configuration structures and loading logic for Actions (including workflow directories, retention policies, and storage), Admin (user feature disabling), API (Swagger, paging, blob limits), Attachments (allowed types, storage, size limits), and Audit (record output, retention). This change provides a more structured and maintainable way to manage these specific subsystem settings within the application configuration.

modules/setting · high confidence

Refactor git module into modular components and introduce new archive and blame APIs

The git module has been restructured into distinct files (archive, blame, blob, branch, catfile\_batch) to improve maintainability and separation of concerns. This change introduces new public APIs for creating git archives and bundles via CreateArchive and CreateBundle, and provides a streaming BlameReader for efficient file blame analysis that respects .git-blame-ignore-revs. The cat-file batch operations are now abstracted behind a CatFileBatch interface, supporting both the modern --batch-command (Git \>= 2.36) and legacy --batch/--batch-check modes. These changes are internal to the modules/git package and do not alter the external API surface for users.

modules/git · high confidence

Refactor issue model layer into models/issues package

The issue-related data access logic has been reorganized into the models/issues package, introducing dedicated files for managing assignees, code comments, comment lists, issue lists, content history, dependencies, labels, locking, and project associations. This structural change consolidates the core issue and pull request persistence logic, including bulk loading of related attributes (repositories, posters, labels, milestones, projects) and specialized operations like fetching code review comments and managing issue dependencies.

models/issues · high confidence

Refactor markup rendering into modular processor files

The markup rendering logic in modules/markup has been restructured from a monolithic html.go file into separate, focused files (html\_codepreview.go, html\_commit.go, html\_email.go, html\_emoji.go, html\_issue.go, html\_link.go, html\_mention.go, html\_node.go). This change introduces a new camo.go module for media proxying and updates the post-processing pipeline to use these distinct processors, improving code maintainability and separation of concerns for features like code previews, commit links, email detection, emoji rendering, issue references, and link handling.

modules/markup · high confidence

Refactored authentication source implementations into dedicated service packages

The internal structure of the authentication system has been reorganized to improve modularity and reduce import cycles. The DB, LDAP, and OAuth2 authentication sources have been moved from the models layer into their own dedicated packages under \services/auth/source/\. This change introduces explicit interface assertions (e.g., \assert\_interface\_test.go\) to ensure that each source correctly implements the expected \auth.PasswordAuthenticator\ and \auth\_model.Config\ interfaces. For LDAP, this includes a new \SecurityProtocol\ type and dedicated search/sync logic, while OAuth2 now uses a provider-based architecture with \GothProvider\ interfaces to manage providers like AWS Cognito and OpenID Connect more cleanly.

services/auth · high confidence

Repository model code and tests moved to models/repo sub-package

The repository model implementation and its associated tests have been reorganized into the new \models/repo\ sub-package. This change includes the migration of core repository logic (such as archive handling, attachments, avatars, collaboration, forking, and search) along with their unit tests, establishing a clearer modular structure for repository-related data access.

models/repo · high confidence

User model code reorganized into the models/user package

The user model implementation has been restructured by moving related files (such as avatar handling, email addresses, search logic, system users, and settings) into the dedicated \models/user\ sub-package. This change improves code organization and modularity without altering the external API or user-facing behavior.

models/user · high confidence

Behavioural changes

2 commits (0 fixes) modifying modules/cachegroup

A change to existing behaviour in modules/cachegroup — 2 commits, 1 file: “perf(pull): load the repository once for all commit statuses (\#39930)”; “Cache GPG keys, emails and users when list commits (\#34086)” (refs \#39930, \#34086).

modules/cachegroup · medium confidence · unverified

2 commits (0 fixes) modifying modules/packages/terraform\_module

A change to existing behaviour in modules/packages/terraform\_module — 2 commits, 4 files: “feat(packages): add private Terraform module registry (\#38040)”; “refactor: lazy init global regexp variables (\#40269)” (refs \#38040, \#40269).

_modules/packages/terraform\module · medium confidence · unverified

2 commits (1 fix) modifying (repo-wide)

A change to existing behaviour in (repo-wide) — 2 commits (1 fix), 4 files: “fix(packages): rebuild repository index after removing a package (\#40306)”; “feat(packages): expose package file properties in the package files API (\#40066)” (refs \#40306, \#40066).

(repo-wide) · medium confidence · unverified

3 commits (0 fixes) modifying modules/git/gitrepo

A change to existing behaviour in modules/git/gitrepo — 3 commits, 2 files: “feat!: remove repository adopt feature (\#40181)”; “refactor: clean up git repo and model migration packages (\#38564)”; “refactor: hide git repo path details from more packages (\#38601)” (refs \#40181, \#38564, \#38601).

modules/git/gitrepo · medium confidence · unverified

5 commits (1 fix) modifying modules/packages/chef

A change to existing behaviour in modules/packages/chef — 5 commits (1 fix), 2 files: “fix: optimize packages upload memory (\#39366)”; “chore: Move import path from code.gitea.io/gitea to gitea.dev (\#37873)”; “test: consolidate Go tests (\#39962)”; and 2 more (refs \#39366, \#37873, \#39962, \#40269, \#22554).

modules/packages/chef · medium confidence · unverified

6 commits (2 fixes) modifying routers/api/packages/terraform

A change to existing behaviour in routers/api/packages/terraform — 6 commits (2 fixs), 2 files: “fix(packages): generic package deletion ignores terraform state lock and latest version (\#40302)”; “fix: optimize packages upload memory (\#39366)”; “chore: Move import path from code.gitea.io/gitea to gitea.dev (\#37873)”; and 3 more (refs \#40302, \#39366, \#37873, \#40269, \#39133, …).

routers/api/packages/terraform · medium confidence · unverified

7 commits (0 fixes) modifying models/audit

A change to existing behaviour in models/audit — 7 commits, 7 files: “enhance(admin): allow regenerating access tokens for bot accounts (\#40109)”; “feat: manage bot accounts from the admin UI, API and CLI (\#38966)”; “feat(auth)!: remove support for obsolete OpenID 2.0 draft (\#40231)”; and 4 more (refs \#40109, \#38966, \#40231, \#39962, \#30205, …).

models/audit · medium confidence · unverified

Actions model layer refactoring and test coverage

The \models/actions\ package has been restructured into a set of focused, single-responsibility files (e.g., \run\_list.go\, \run\_job\_list.go\, \runner\_list.go\, \config.go\) with comprehensive unit tests added for each. This change introduces new capabilities for managing Actions, including configurable token permissions for owners (\config.go\), improved job queue sorting and matrix group handling (\run\_job\_list.go\), and better support for scoped workflows and run attempts (\run\_list.go\, \run\_attempt\_list.go\). The refactoring also adds tests for runner heartbeat logic, status aggregation, and artifact retention, ensuring the underlying data access and business logic are robust and well-covered.

models/actions · high confidence

Add nsswitch configuration and s6-svscan finish script

The Docker image now includes a new /etc/nsswitch.conf file to define name service switching behavior (e.g., hosts resolution via files and DNS) and a finish script for the s6-svscan service to ensure clean exit handling.

docker/root/etc, docker/root/etc/s6/.s6-svscan · high confidence

Adopts experimental Go JSON v2 library for serialization

The JSON handling module now uses Go's experimental \encoding/json/v2\ library as the default backend, replacing the previous standard library implementation. This change introduces updated serialization behaviors, such as formatting nil slices and maps as null by default and supporting case-insensitive field matching during unmarshaling. The module provides a unified interface that abstracts the underlying library, allowing the application to benefit from the new library's performance and features while maintaining compatibility with existing code.

modules/json · high confidence

Alpine package metadata parsing with entry limits

The Alpine package module now includes logic to parse PKGINFO files and extract detailed metadata (such as name, version, dependencies, and architecture) while enforcing a limit of 1024 entries to prevent excessive memory usage. This change introduces specific error handling for missing or invalid package information and bounds the number of dependency and provider entries processed during parsing.

modules/packages/alpine · high confidence

Asymmetric key management logic moved to models/asymkey

The core logic for managing SSH and GPG keys has been consolidated into the new models/asymkey package. This includes dedicated files for GPG key operations (adding, listing, verifying, and commit verification) and SSH key operations (parsing, fingerprint calculation, authorized keys generation, and principal handling). The change introduces a native Go parser for SSH public keys, replaces the previous crypto library with ProtonMail/go-crypto for GPG operations, and implements a structured error system for key-related failures.

models/asymkey · high confidence

Centralized HTTP form binding and validation rules

The \modules/validation\ package now provides a unified \Binder\ that automatically applies validation rules to HTTP form fields. This change introduces specific validation for email addresses, Git reference names, URLs, glob patterns, regex patterns, usernames, and badge slugs, ensuring that user inputs are checked against defined constraints at the binding layer rather than scattered across individual handlers.

modules/validation · high confidence

Centralized access mode definitions in models/perm

The access mode types and parsing logic have been moved into the models/perm package. This change consolidates the definition of access levels (none, read, write, admin, owner) and their string representations into a single location, making it easier to manage and verify permission modes across the application.

models/perm · high confidence

Centralized repository permission and access management

Repository access logic and permission checks have been moved into the new models/perm/access package. This change introduces a unified Permission struct that handles granular unit-level access (code, issues, PRs, wiki, actions) and distinguishes between signed-in user access, anonymous access, and public/everyone access modes. It also includes optimized database operations for recalculating and refreshing access records, ensuring that access updates are performed via selective inserts, updates, and deletes rather than full table truncation and re-insertion. Additionally, specific tests verify that Actions tokens and fork pull requests correctly enforce cross-repo trust boundaries and permission clamping.

models/perm/access · high confidence

Code editor engine switched from Monaco to CodeMirror

The web-based code editor now uses CodeMirror instead of Monaco, bringing a new command palette (F1), a context menu with features like 'Go to Definition' and 'Change All Occurrences', and improved language detection for files like Dockerfiles and Makefiles. This change also adds a built-in linter for JSON syntax errors and allows users to click URLs in code by holding Ctrl/Cmd.

_web\src/js/modules/codeeditor · high confidence

Code indexer now supports skipping forks, mirrors, and templates

The code indexer in modules/indexer/code now respects the \RepoIndexerRepoTypes\ setting, allowing administrators to exclude forks, mirrors, and templates from being indexed. Previously, these repository types were always indexed if the indexer was enabled; now, if a specific type (e.g., 'forks') is not listed in the configuration, repositories of that type will be skipped during the indexing process, reducing storage and processing overhead for users who do not need to search code within forks or mirrors.

modules/indexer/code · high confidence

Combined commit status now treats warnings as failures

The \modules/commitstatus\ module's \Combine\ method has been updated so that any commit status context reporting a \warning\ state causes the overall combined status to be \failure\. Previously, warnings may have been treated differently (e.g., ignored or resulting in a different state), but this change aligns the combined status logic with the behavior that warnings are critical enough to fail the build, ensuring consistency between the API and UI representations of commit status.

modules/commitstatus · high confidence

Configurable password hash algorithms with parameterized backends

The password hashing module has been refactored to support configurable parameters for bcrypt, PBKDF2, scrypt, and Argon2, allowing administrators to tune security settings via the app.ini configuration. This change introduces a new registration system for hash algorithms, adds a dummy hasher for faster testing, and updates the default PBKDF2 iteration count to 50,000 (previously 10,000) to improve security while maintaining backward compatibility with existing stored hashes.

modules/auth/password/hash · high confidence

Container registry router refactored into dedicated package files

The container registry HTTP handlers have been reorganized from a single monolithic file into separate, focused files (blob.go, container.go, manifest.go, errors.go). This change improves code maintainability and clarity by isolating blob upload/mount logic, authentication and access control, manifest processing, and error definitions into their own modules, without altering the external API behavior.

routers/api/packages/container · high confidence

Database schema migrations for v1.27 features

This release includes database migrations that add a visibility column to the team table to support team discovery within organizations, add a last sync timestamp to mirrors, and expand text fields in the issue and comment tables to LONGTEXT to prevent truncation of long content on MSSQL. It also fixes legacy MSSQL datetime columns in external login and LFS lock tables to ensure correct parsing, and adds unique indexes for user badges to prevent duplicates.

gitea.dev · high confidence

Docker entrypoint now manages SSH permissions and environment-driven configuration

The Docker container's startup process has been updated to ensure SSH functionality works correctly by automatically setting strict permissions (700 for .ssh, 600 for authorized\_keys) on the data volume. Additionally, the entrypoint now generates the app.ini configuration file from environment variables (such as GITEA\_CUSTOM, DOMAIN, SSH\_PORT, and LFS\_START\_SERVER) using a template and the new environment-to-ini tool, and ensures the GITEA\_CUSTOM environment variable is propagated to SSH sessions via an environment file. The service is also configured to cleanly stop all s6-managed services upon shutdown.

docker/root/etc/s6/gitea · high confidence

Docker entrypoint script updated to use /usr/local/bin/gitea and correct working directory

The Docker image now installs a wrapper script at /usr/local/bin/gitea that configures default paths for the application binary (/app/gitea/gitea) and working directory (/data/gitea). This script sets environment variables for the working directory and custom path before executing the main Gitea binary, ensuring correct operation within the container environment. Additionally, a new environment-to-ini helper script is introduced to support configuration management via environment variables.

docker/root/usr/local · high confidence

Emoji module rewritten with lazy-loading, trie-based detection, and skin-tone support

The emoji processing module has been completely rewritten to improve performance and accuracy. It now lazy-loads emoji data from assets/emoji.json using a global atomic pointer, ensuring efficient initialization. Detection uses a slice-based Trie for faster lookup of emoji positions in text, replacing previous regex-based methods. The module now fully supports Unicode skin-tone variants and complex emoji sequences (like ZWJ sequences) by correctly handling skin-tone modifiers during matching. Additionally, users can now restrict available emojis via the UI.EnabledEmojisSet setting, allowing administrators to disable specific emojis entirely.

modules/emoji · high confidence

Enforce two-factor authentication (2FA) for user accounts

Users are now required to configure and enable two-factor authentication (supporting TOTP or WebAuthn) to access their accounts. This change introduces a mandatory security step during login, ensuring that all users have an additional layer of protection beyond their password. Administrators may also configure LDAP sources to bypass this local 2FA requirement.

services · high confidence

Extracted frontend CSS into dedicated module files

The monolithic frontend stylesheets have been refactored into separate, dedicated CSS files (such as actions.css, admin.css, and avatar.css) to improve maintainability and organization. This change isolates styling rules for specific UI areas—like the Actions runner interface, admin dashboards, and avatar rendering—into their own modules, ensuring that styles are scoped correctly and easier to manage without affecting unrelated components.

_web\src · high confidence

Improved Gitea Actions workflow parsing and execution

The \modules/actions/jobparser\ module has been refactored to use the shared \actionslib\ model, bringing several behavioral improvements to workflow execution. YAML anchors and aliases are now fully resolved during parsing, with safeguards against excessive expansion and rejection of unsupported merge keys. Dynamic matrix strategies that depend on \needs\ outputs are now correctly deferred until those jobs complete, preventing premature expansion errors. Additionally, the parser now supports the \$/\ prefix for reusable workflow references, handles \continue-on-error\ expressions at the job level, and ensures that multi-line \run\ blocks round-trip correctly without stranding jobs during concurrency evaluation.

modules/actions/jobparser · high confidence

Improved OpenAPI 3.0 spec generation with better enum and schema handling

The OpenAPI 3.0 specification generator now produces cleaner, more accurate API documentation by converting Swagger 2.0 specs with enhanced post-processing. It automatically fixes Swagger 2.0 'file' types to the correct OpenAPI 3.0 'string' with 'binary' format, adds 'uri' formats to URL properties, and correctly flags deprecated properties based on description markers. Additionally, it extracts shared enum definitions into named schemas for better code generation, using Go source annotations to name them accurately.

build/openapi3gen · high confidence

Improved SSH startup reliability and configuration flexibility

The Docker container's SSH service now includes a finish script that introduces a 3-second delay before restarting if the sshd process exits with an error, preventing rapid restart loops and high CPU usage during configuration failures. The setup script ensures host keys are generated with a minimum RSA key length of 3072 bits and supports loading extra sshd\_config parameters via an Include file, as well as configuring the log level and listening port through environment variables. Additionally, the service now correctly handles host certificates by checking both standard and alternate certificate file locations.

docker/root/etc/s6/openssh · high confidence

Improved Unicode character detection and escaping in file views

The \modules/charset\ module has been refactored to enhance how ambiguous and invisible Unicode characters are handled in web displays. It now uses a generated, locale-aware table of ambiguous characters (derived from VSCode's unicode data) to better distinguish between similar-looking glyphs, particularly for Chinese locales. The new escape streamer intelligently avoids escaping characters within long non-ASCII sentences to reduce visual noise, while still detecting and escaping dangerous bidirectional (BIDI) control characters and invisible runes in code and commit messages. This results in more accurate rendering of mixed-script text and improved security against Unicode-based injection attacks in diffs and page renders.

modules/charset · high confidence

Improved accessibility and reliability for dropdowns, modals, and checkboxes

The Fomantic UI components in the frontend now include dedicated patches to enhance accessibility and fix behavioral issues. Dropdowns now support ARIA roles (combobox/listbox) and keyboard navigation for screen readers, while also preserving literal string values like "false" in choice options and hiding empty dividers. Modals now prevent form submission abuse by ensuring the dialog stays open during validation errors and correctly handling Enter key presses on cancel buttons. Checkboxes and form fields are automatically linked with proper labels for better screen reader support, and UI transitions are handled via CSS classes instead of the removed Fomantic transition module.

_web\src/js/modules/fomantic · high confidence

Improved code search tokenization for alphanumeric identifiers

The Bleve code indexer now uses a custom tokenizer and token filter that split alphanumeric tokens into separate letter and number parts (e.g., 'port123' becomes 'port123', 'port', '123'). This change improves search accuracy for code snippets containing mixed identifiers and numbers, ensuring that queries for specific parts of such tokens are correctly matched.

modules/indexer/code/bleve · high confidence

Improved file type detection for SVG, AVIF, and OGG formats

The file type sniffer now correctly identifies SVG images, AVIF images, and distinguishes between audio and video OGG files. Previously, SVG files were often misidentified as plain text or HTML, and OGG containers were not differentiated by their internal codec (Theora/Director vs. Vorbis). The module also fixes false positives for MP3 files containing ID3 tags that are actually text, and corrects Go's standard library's tendency to misidentify certain binary data as Microsoft Font Objects.

modules/typesniffer · high confidence

Improved issue search accuracy with custom tokenization and assignee filtering

The Bleve-based issue indexer has been updated to provide more accurate search results and better filtering capabilities. A custom 'camelCaseKeepWhole' token filter now ensures that multi-word camelCase terms (e.g., 'someThing') are indexed as both their component parts and the full original word, allowing users to find issues by typing the complete term. The indexer also now supports filtering issues by any assignee, including specific users, multiple assignees, or unassigned issues, via the new \assignee\_ids\ and \no\_assignee\ index fields. Additionally, the search logic dynamically adjusts fuzziness based on keyword length to reduce false positives in fuzzy matching.

modules/indexer/issues/bleve · high confidence

Improved natural sort order for repository entries

The repository tree and file lists now sort entries using a natural sort algorithm that correctly handles numeric sequences (e.g., 'file2' comes before 'file10') and respects leading zeros (e.g., 'file0001' sorts before 'file2'). This change fixes previous inconsistencies where numeric parts were sorted lexicographically, ensuring that version numbers and file indices appear in the expected human-readable order.

modules/base · high confidence

Internal SSH server now respects configurable ciphers, key exchanges, and MACs

The built-in SSH server now allows administrators to configure the allowed ciphers, key exchange algorithms, and MACs via the SSH settings. When the server is started, it logs the specific cryptographic suites in use (or defaults if none are specified), ensuring that the server's security posture aligns with organizational policies. This change replaces the previous behavior where these parameters were likely hardcoded or defaulted, giving users explicit control over the cryptographic negotiation for SSH connections.

modules/ssh · high confidence

Introduce OS-native user detection with environment variable fallback

The modules/user package now determines the current operating system username using the native Go os/user library instead of relying on environment variables. This change improves reliability across different platforms, particularly Windows, by handling domain prefixes correctly. As a fallback mechanism, the system still checks the USER and USERNAME environment variables if the native method fails, ensuring backward compatibility. A corresponding test suite verifies this behavior against the system's whoami command.

modules/user · high confidence

Introduce configurable SSH and application settings via Docker templates

The Docker image now uses templated configuration files for the application and SSH daemon, allowing runtime customization of key settings. The new app.ini template exposes environment variables for the application domain, SSH domain, HTTP port, SSH listen port, LFS server status, database connection details, and security options like registration disablement. The sshd\_config template enables configuration of the SSH listen port, connection limits (MaxStartups/MaxSessions), log level, and user allowances, while also supporting SSH certificate integration and custom include files for extended SSH configuration.

docker/root/etc/templates · high confidence

Introduce database-backed repository language statistics indexer

The repository language statistics feature now uses a dedicated DBIndexer backed by a queue system instead of the previous implementation. This change introduces a new stats indexer package that calculates language statistics for non-empty repositories, handles missing default branches gracefully, and persists the results to the database. Users will see language stats indexed via a background queue, with improved error handling for missing repository directories or branches.

modules/indexer/stats · high confidence

Introduce generic, revision-aware configuration retrieval system

The configuration module now uses a new generic \Option\[T\]\ type to retrieve settings, supporting both static file-based and dynamic database-backed values. This system automatically tracks configuration revisions, allowing the application to detect and invalidate cached config values when the database is updated, ensuring that runtime configuration changes are reflected immediately without requiring a restart.

modules/setting/config · high confidence

Introduce internal indexer base components

Added internal helper utilities for the issue indexer, including a base32 encoding/decoding implementation, a basic Indexer interface with a dummy implementation for testing or fallback, and a paginator parser that converts db.ListOptions into skip and limit values while respecting engine-specific page size limits.

modules/indexer/internal · high confidence

Introduce internal issue indexer interface and data models

This change establishes the foundational internal API for the new issue indexer by adding the \Indexer\ interface and \SearchOptions\/\IndexerData\ models. It defines the contract for indexing, deleting, and searching issues, including support for filtering by assignees, labels, projects, and status (closed/archived), as well as sorting by various fields. A dummy implementation is provided to handle cases where the indexer is not ready, ensuring backward compatibility during the transition.

modules/indexer/issues/internal · high confidence

Introduce secure attribute protection and final processing in markup rendering

The markup rendering pipeline now includes an internal mechanism to safely handle HTML attributes by temporarily renaming them (e.g., \class\ becomes \data-attr-class\) during processing to prevent injection, then restoring them in the final output. This change also adds a \finalProcessor\ that injects extra head HTML into the rendered output when present, ensuring that specific metadata or scripts are correctly placed within the HTML structure.

modules/markup/internal · high confidence

Introduce shared helper utilities for the package registry API

A new helper package is added to standardize error handling and file serving within the package registry. It provides functions to map internal errors to appropriate HTTP status codes (404 or 500) and to process errors for users, ensuring that internal server error details are hidden from non-admin users in production environments. Additionally, it includes a utility to serve package file content, supporting both direct content delivery and URL-based redirection.

routers/api/packages/helper · high confidence

Introduce structured graceful shutdown lifecycle with systemd support

The \modules/graceful\ package has been rewritten to provide a robust, multi-stage shutdown process (Shutdown, Hammer, Terminate) exposed via dedicated \context.Context\ values, allowing components to clean up gracefully or force-stop within defined timeframes. This update adds native support for the systemd \NOTIFY\_SOCKET\ protocol, enabling proper status reporting (Ready, Stopping, Watchdog) and process management for Linux deployments, while also implementing graceful restart capabilities for Unix sockets and Windows services.

modules/graceful · high confidence

Introduce structured migration data models and file validation

The migration module now defines explicit Go structs for core repository entities—including issues, comments, pull requests, reviews, milestones, labels, releases, and reactions—standardizing the data format for import and export operations. Additionally, a new file format layer has been added that supports loading migration data from JSON and YAML files, featuring schema validation via JSON Schema to ensure data integrity during the migration process.

modules/migration · high confidence

Migrate build and CI tooling to TypeScript and Node.js 22

The \tools\ directory has been migrated from shell scripts and Go to TypeScript and Node.js, requiring Node.js version 22.18.0 or higher. This change introduces a suite of new TypeScript-based utilities for CI and development workflows, including \ci-tools.ts\ for validating and syncing PR labels, \generate-codemirror-languages.ts\ for updating syntax highlighting definitions, and \generate-images.ts\ for processing assets. The previous Go-based coverage merging tool (\gocovmerge.go\) and Go linting orchestrator (\lint-go-all.go\) remain, but the broader tooling ecosystem is now Node-centric.

tools · high confidence

Migrate frontend asset serving from webpack to Vite

The public module now supports the Vite build tool, replacing the previous webpack-based asset pipeline. This change introduces a manifest parser to resolve content-hashed production assets and a development middleware that proxies requests to the Vite dev server for hot module replacement. It also includes a dedicated MIME type detector to ensure stable Content-Type headers for well-known file extensions, bypassing potentially unstable OS-level configurations.

modules/public · high confidence

Migrate frontend build system from Webpack to Vite

The frontend build process has been migrated from Webpack to Vite, resulting in faster development server startup and improved build performance. This change updates the underlying tooling used to compile and bundle the application's JavaScript and CSS assets, which may affect local development workflows and custom asset configurations.

templates · high confidence

NPM registry API response structure and routing implementation

The NPM package registry now exposes its API endpoints through a dedicated router and response builder in the \routers/api/packages/npm\ package. This change introduces structured JSON responses for package metadata and search results, ensuring that fields like \repository\, \keywords\, and \maintainers\ are correctly populated from package properties. It also implements proper URL escaping for tarball paths to handle scoped packages (e.g., \@scope/name\) and internal package versions, while adding a search endpoint that returns paginated results with scope and publisher details.

routers/api/packages/npm · high confidence

New TypeScript-based admin UI modules for configuration, user management, and self-checks

The admin interface now uses new TypeScript modules (common, config, selfcheck, users) to handle dynamic form mapping, bulk runner actions, and frontend self-checks. This replaces previous JavaScript implementations with stricter typing and improved maintainability, ensuring consistent behavior for admin configuration updates and user list filtering.

_web\src/js/features/admin · high confidence

New admin UI templates for LDAP, OAuth2, SMTP, and SSPI authentication sources

The admin interface for configuring authentication sources now uses dedicated, structured HTML templates for LDAP, OAuth2, SMTP, and SSPI. This change introduces specific form fields for each provider type, including LDAP group synchronization and team mapping, OAuth2 claim mapping (full name, SSH public key, external ID, groups) and custom URL settings, SMTP security options, and SSPI user auto-creation and language settings. The templates also standardize the UI by using Tailwind CSS utility classes (e.g., \tw-hidden\) for conditional field visibility and ensure all labels are localized via the locale system.

templates/admin/auth · high confidence

New container entrypoint script for Alpine 3.15 compatibility and user configuration

A new entrypoint script has been added to handle the upgrade to Alpine 3.15, including a check to prevent running on Docker versions older than 20.10.6 due to runc compatibility issues. The script now supports configurable user IDs and group IDs via environment variables (USER\_UID, USER\_GID), allowing users to customize the container's user context. It also ensures necessary directories are created and defaults to starting the s6-svscan service if no command is provided.

docker/root/usr/bin · high confidence

New git command execution module

The git command execution logic has been moved into a new \modules/git/gitcmd\ package. This change introduces a structured \Command\ builder with strict argument validation to prevent injection risks, standardized error handling that exposes git's stderr output, and improved context and pipe management for running git processes.

modules/git/gitcmd · high confidence

New search capabilities and access controls for Alpine, Arch, Conda, and CRAN package registries

The package model layer now includes dedicated search functions for Alpine, Arch, Conda, and CRAN registries, enabling users to filter packages by specific attributes such as branches, repositories, architectures, channels, subdirs, and file types. Additionally, the system enforces restricted access for limited-owner packages by verifying blob accessibility at the model level, ensuring that only authorized users can retrieve package files.

models/packages · high confidence

Organization models refactored into dedicated package with enhanced visibility and worktime tracking

The organization-related model logic has been moved into a dedicated \models/organization\ package, introducing a cleaner structure for managing organizations, teams, and memberships. This change adds organization-level worktime tracking capabilities, allowing users to view time spent aggregated by repository, milestone, or team member. It also refines visibility controls, ensuring that restricted users cannot access limited-visibility organizations and that team visibility respects the \DEFAULT\_ORG\_MEMBER\_VISIBLE\ setting. The new structure includes optimized batch loading for organization teams and members, and adds support for team member invitations via email.

models/organization · high confidence

Project column management and sorting logic

The project model now includes dedicated logic for managing project columns, including functions to count, retrieve (with pagination), and fetch columns by ID. It enforces a maximum limit on the number of columns per project and ensures that column sorting does not wrap around at the integer maximum. Additionally, the model supports retrieving default columns and moving issues between columns, while tests verify correct pagination, sorting behavior, and limit enforcement.

models/project · high confidence

Queue module rewritten with new base implementations and manager

The queue module has been completely rewritten to introduce a new architecture with distinct base queue implementations (channel, LevelDB, Redis, and dummy) that share a common interface. This change adds support for unique queues that prevent duplicate items, introduces a centralized Manager for creating and flushing managed queues, and implements a WorkerPoolQueue that handles batching, worker lifecycle, and unhandled item requeuing with backoff. The new system also includes a backoff mechanism for retries and notification signals to improve responsiveness when pushing to empty queues.

modules/queue · high confidence

Refactor Actions module into modular components with scoped workflow support

The Actions module has been restructured into distinct, focused files to improve maintainability and add new capabilities. Artifact handling now uses a dedicated \BuildSignature\ function for unambiguous HMAC signatures. Workflow event matching is decoupled into \github.go\ to align Gitea webhook events with GitHub Actions event types, while \workflowpattern\ implements GitHub-compatible globbing for branch and path filters. The system now supports scoped workflows (under \SCOPED\_WORKFLOW\_DIRS\) with dedicated parsing and matching logic. Task state management is refined in \task\_state.go\ to correctly display 'Set up job' and 'Complete job' steps, including proper handling of skipped and cancelled states. Log storage is optimized via \log.go\ with compression and DBFS-to-object-storage transfer, and commit status integration is improved via \commit\_status\_info.go\ to reflect live ActionRunJob statuses.

modules/actions · high confidence

Refactor code indexer to use SearchOptions struct

The code indexer's search interface has been updated to accept a dedicated SearchOptions struct, which groups search parameters such as repository IDs, keywords, language filters, and pagination settings. This change simplifies the Search method signature and provides a more structured way to pass search criteria, improving maintainability and clarity for future search enhancements.

modules/indexer/code/internal · high confidence

Refactor container package registry with dedicated blob uploader and cleanup logic

The container package registry service has been refactored to improve reliability and maintainability. A new \BlobUploader\ component in \blob\_uploader.go\ now handles chunked blob uploads with proper state management, addressing previous data race issues during concurrent uploads. Dedicated cleanup logic in \cleanup.go\ ensures that expired blob uploads and unreferenced uploaded blobs are properly removed. Common utilities in \common.go\ have been consolidated to handle repository name updates and manifest metadata parsing, providing a cleaner separation of concerns within the container package service.

services/packages/container · high confidence

Refactor options asset loading to use layered assetfs

The options module now uses a layered asset filesystem approach to serve static content like locales, readmes, gitignores, licenses, and labels. This change introduces a new base.go file that defines helper functions (Locale, Readme, Gitignore, License, Labels) which delegate to a unified AssetFS. This AssetFS is constructed by layering custom assets (from the user's custom path) over builtin assets. The builtin assets are now provided via two build-tagged files: options\_bindata.go (for bindata builds, embedding a bindata.dat file) and options\_dynamic.go (for non-bindata builds, reading from the static root path). This replaces previous direct file reading or simpler asset access patterns with a consistent, layered lookup mechanism.

modules/options · high confidence

Refactor translation module to use JSON locale files and new i18n interface

The translation module has been refactored to load locale data from JSON files instead of the previous format, and now implements a new \Locale\ interface with a \MockLocale\ for testing. This change introduces support for sorting languages by name, uses \en-US\ as a fallback when other default languages are configured, and adds a watcher to reload locales on file changes in non-production environments.

modules/translation · high confidence

Refactor webhook model to use context.Context and add system webhook support

The webhook model layer has been refactored to replace the legacy db.Engine parameter with context.Context across all database operations, improving consistency with the rest of the codebase. Additionally, new functionality has been introduced to manage system and default webhooks, including methods to list, retrieve, delete, and copy global (admin-configured) webhooks to repositories. The test suite has been updated to reflect these changes, including new tests for system webhook options and data preparation.

models/webhook · high confidence

Refactored Bleve indexer with automatic batching and improved search fuzziness

The Bleve indexer implementation has been restructured to improve performance and search accuracy. A new FlushingBatch mechanism automatically flushes index operations to the underlying store once a configurable size limit is reached, optimizing write throughput. Additionally, search fuzziness is now dynamically calculated based on keyword length and character type, disabling fuzzy matching for non-letter characters (such as CJK scripts or file extensions) to prevent irrelevant matches.

modules/indexer/internal/bleve · high confidence

Refactored activity and notification models into the activities package

The code in models/activities has been reorganized into a dedicated package, introducing new files for action lists, notifications, repository activity statistics, user heatmaps, and general statistics. This refactoring adds context-aware loading methods for actions (users, repositories, issues, comments) to improve performance and consistency, implements a robust notification system that handles issue watchers, assignees, reviewers, and respects mute settings, and provides detailed repository activity stats including code commit counts and issue/PR metrics. User activity heatmaps are now generated with timezone-aware grouping, and database statistics are centralized. Tests have been added to verify notification logic, action consistency, and heatmap data accuracy.

models/activities · high confidence

Refactored avatar module with unified hashing and federated lookup

The avatar module has been restructured to support custom avatar uploads, default fallbacks, and federated avatar lookups. Users can now upload custom avatars (PNG, JPEG, GIF, WebP) which are automatically cropped to square and resized using a bilinear scaler. The system generates deterministic random avatars based on email hashes and supports federated avatar resolution via DNS SRV records (Libravatar protocol) with caching. Avatar hashing now includes a unique user ID to prevent collisions between users with identical avatar data.

modules/avatar · high confidence

Refactored branch and LFS lock models with improved protection and ownership handling

The \models/git\ package has been reorganized into dedicated files for branches, protected branches, LFS locks, and commit statuses, introducing more robust and testable logic. Branch lookups now support stable ordering and keyword filtering, while protected branch rules are sorted by explicit priority and glob specificity to ensure correct matching. LFS lock operations now strictly enforce repository ownership, preventing cross-repo lock manipulation. Additionally, a new \IsRefProtected\ utility unifies branch and tag protection checks, and deleted branch metadata now correctly loads user information.

models/git · high confidence

Refactored cache module with new adapters and request-level context caching

The cache module has been refactored to use the go-chi/cache library, introducing a unified StringCache interface and dedicated adapters for Redis (via go-redis/v9) and in-memory LRU 2Q caching. This change adds request-level ephemeral caching via context values to optimize repeated lookups within a single request, and introduces a SafeCacheKey utility to handle character and length limits for backends like Memcached. Additionally, a new cachegroup package defines standardized key prefixes for user, email, and GPG key data to improve cache organization.

modules/cache · high confidence

Refactored database connection and collation handling for MySQL and MSSQL

The database initialization logic in models/db has been restructured to improve connection string generation and database consistency checks. Connection string construction for MySQL, PostgreSQL, MSSQL, and SQLite is now centralized in new conn.go files, supporting modern SQLite drivers and explicit schema handling for PostgreSQL. Additionally, a new collation check system (collation.go) automatically detects and adjusts database and table collations for MySQL and MSSQL to ensure case-sensitivity where required, and warns users if inconsistencies are found.

models/db · high confidence

Refactored dump module to use mholt/archives for unified archive creation

The dump module has been refactored to replace the previous archiving implementation with the github.com/mholt/archives library. This change introduces a new Dumper component that supports a wider range of output formats, including zip, tar, tar.sz, tar.gz, tar.xz, tar.bz2, tar.br, tar.lz4, and tar.zst. The default output type is now 'zip' (using Deflate compression), and the module provides improved handling for file inclusion/exclusion and path normalization across different operating systems.

modules/dump · high confidence

The web middleware module has been restructured to improve form binding, validation, and cookie management. A new binding system (binding.go) centralizes request-to-struct mapping and validation error translation, ensuring consistent user-facing error messages for fields like emails, URLs, and custom patterns. Cookie handling (cookie.go) now explicitly manages legacy cookie paths to prevent precedence issues and applies configured SameSite, Secure, and HttpOnly attributes consistently. Additionally, locale parsing (locale.go) now bounds the Accept-Language header length to prevent potential denial-of-service from malformed inputs, and flash messages (flash.go) are standardized for reliable one-time data transfer between requests.

modules/web/middleware · high confidence

Refactored frontend components to TypeScript with improved editor and workflow behaviors

The components in the \web\_src/js/features/comp\ directory have been converted to TypeScript, introducing stricter type safety across the codebase. This change brings several behavioral improvements: the markdown editor now handles list indentation and newline formatting more robustly, preventing issues with numbered lists and IME composition; avatar uploads now support cropping before saving; and the confirmation modal UI has been updated to use red for destructive actions. Additionally, scoped workflow configurations now provide real-time context matching and pattern validation, while label editing includes better handling of exclusive scopes and archival states.

_web\src/js/features/comp · high confidence

Refactored internal API communication and added Proxy Protocol support

The internal communication layer in modules/private has been refactored to use a new HTTP-based transport (internal.go) that supports both Unix sockets and loopback network connections, with TLS verification skipped only for local targets to prevent MITM attacks on non-loopback addresses. This change introduces dedicated client wrappers for Git hooks (hook.go), SSH service commands (serv.go), Actions runner tokens (actions.go), and repository restoration (restore\_repo.go), replacing previous direct database or hook-execution patterns. Additionally, modules/proxyprotocol now provides full support for HAProxy Proxy Protocol v1 and v2, allowing Gitea to correctly identify real client IPs when running behind a load balancer or reverse proxy.

modules/private · high confidence

Refactored issue indexer to use a unified SearchOptions struct and context.Context

The issue indexer module has been restructured to decouple database-specific search options from the generic indexer interface. A new \SearchOptions\ struct and a \ToSearchOptions\ conversion function in \dboptions.go\ now handle the mapping from \IssuesOptions\ to indexer-specific filters (such as labels, milestones, and assignees) using \optional.Option\ types. The core \indexer.go\ and \util.go\ files have been updated to accept \context.Context\ for all operations, improving lifecycle management and allowing for better cancellation and timeout handling during indexing and search operations.

modules/indexer/issues · high confidence

Refactored markdown rendering to use Goldmark and added custom URL scheme handling

The markdown rendering engine in modules/markup/common has been migrated from blackfriday to Goldmark, introducing a new footnote implementation and linkify parser that aligns more closely with GitHub's behavior. Additionally, a new URL scheme validation system has been added, allowing administrators to configure allowed custom URL schemes while strictly blocking dangerous schemes like javascript and data by default.

modules/markup/common · high confidence

Refactored syntax highlighting engine with Chroma v2 and optimized lexer detection

The code highlighting module has been rewritten to use the Chroma v2 library, replacing the previous implementation. This change introduces a new, high-performance lexer detection system that pre-builds lookup maps for file names, extensions, and language aliases to avoid slow runtime analysis. The refactoring ensures consistent syntax highlighting across file views and diffs, improves copy-paste behavior by preserving newlines, and adds support for custom highlight mappings beyond standard file extensions. Benchmarks included in the module highlight significant performance gains in lexer detection compared to the previous content-analysis approach.

modules/highlight · high confidence

Refactored template rendering system with improved error reporting and expression evaluation

The template rendering infrastructure in \modules/templates\ has been restructured to improve maintainability and user experience. A new expression evaluation engine (\modules/templates/eval\) now supports arithmetic and logical operations within templates via the \Eval\ helper. Template error reporting has been significantly enhanced with a prettifier that displays the specific line, column, and surrounding code context for syntax and execution errors. The system now supports auto-reloading of templates in non-production modes and provides a unified asset filesystem (\AssetFS\) for managing both built-in and custom template assets.

modules/templates · high confidence

Refactored web routing and handler execution to use reflection-based dependency injection

The \modules/web\ package has been rewritten to replace the previous handler execution model with a reflection-based approach that automatically injects handler arguments (such as \\*http.Request\, \http.ResponseWriter\, and custom \ResponseStatusProvider\ types) at runtime. This change introduces a new \Router\ structure built on \go-chi/chi/v5\ that supports pre-middlewares, path-group matching with regular expressions, and a \Combo\ API for concise route definition. Additionally, a new testing facility (\routemock.go\) allows developers to mock route execution at specific middleware points during tests, improving the ability to isolate and test individual handlers without running the full stack.

modules/web · high confidence

Refactored webhook event and type definitions

The webhook module's internal structure has been reorganized to improve clarity and maintainability. The \modules/webhook/type.go\ file now explicitly defines all supported webhook event types (such as \pull\_request\_review\_approved\, \workflow\_job\, and \workflow\_run\) and webhook delivery types (like \gitea\, \slack\, and \discord\), along with helper methods to categorize events. The \modules/webhook/events.go\ file introduces a new \HookEvents\ map type and a \HookEvent\ struct to manage which specific events are enabled for a given webhook configuration, replacing the previous ad-hoc event handling logic.

modules/webhook · high confidence

Refined vendor and generated file detection for diffs

The analyze module now uses dedicated logic to determine if files are vendored or generated, improving accuracy in diff views. Vendor detection overrides go-enry's default behavior to exclude specific paths like .gitignore, .gitattributes, .github/, and .gitea/ from being marked as vendored. Generated file detection is handled via a new function that checks file extensions and name patterns against known generated code lists. Additionally, code language detection is consolidated into a single function that prioritizes extension and filename before falling back to content analysis.

modules/analyze · high confidence

Replace legacy Elasticsearch client with REST API and add OpenSearch support

The issue indexer in the elasticsearch module has been refactored to replace the older olivere/elastic library with a native REST API client, which also adds support for OpenSearch. This change updates the underlying communication layer for issue search and indexing while maintaining the existing search capabilities, such as filtering by assignee, labels, and project status.

modules/indexer/issues/elasticsearch · high confidence

Replace legacy Elasticsearch client with native REST API implementation supporting OpenSearch

The Elasticsearch indexer module has been rewritten to replace the deprecated \olivere/elastic\ library with a custom implementation using Go's standard \net/http\ client. This change enables compatibility with both Elasticsearch (versions 7, 8, and 9) and OpenSearch (version 3) by targeting their shared REST API subset. The new implementation provides the same core indexing capabilities—bulk operations, single document indexing/deletion, and search queries—while removing external library dependencies and ensuring the indexer works correctly with modern cluster health checks and versioned index management.

modules/indexer/internal/elasticsearch · high confidence

Replace legacy asset bundling with a new layered filesystem supporting embedded and compressed assets

The asset serving mechanism in modules/assetfs has been refactored to use a new layered filesystem architecture. This change introduces support for embedding static assets directly into the binary using Go's standard library, with automatic gzip compression for files where it reduces size. The new system allows multiple asset layers (such as local directories and embedded bindata) to be stacked, with higher-priority layers overriding lower ones, enabling flexible asset resolution for both production builds and development environments.

modules/assetfs · high confidence

Repository statistics consistency checks moved to dedicated models package

The logic for verifying and correcting repository statistics (such as watch counts, star counts, issue numbers, and label metrics) has been relocated from its previous location into a new \models/repostats\ package. This change introduces a structured \repoChecker\ mechanism to identify and fix discrepancies between stored counters and actual database records, ensuring data integrity for repository and label statistics. The move is accompanied by new initialization logic in \models/init.go\ and comprehensive test coverage in \models/repostats\ to validate the consistency checks.

models, models/repostats · high confidence

Repository unit configuration and defaults are now centrally managed and validated

The repository unit system has been refactored to centralize the definition of available unit types (Code, Issues, Pull Requests, Releases, Wiki, Projects, Packages, Actions) and their default configurations for new, forked, mirrored, and template repositories. This change introduces robust validation for the \DisabledRepoUnits\, \DefaultRepoUnits\, \DefaultForkRepoUnits\, \DefaultMirrorRepoUnits\, and \DefaultTemplateRepoUnits\ settings, ensuring that invalid or duplicate unit keys are handled gracefully with warnings rather than causing failures. It also enforces that at least one unit must remain enabled, preventing configurations that would leave a repository without any functional capabilities. Additionally, a thread-safe mechanism using atomic pointers has been implemented to manage globally disabled units, resolving data races during testing.

models/unit · high confidence

Rewrite i18n module to use JSON locale files and stricter argument formatting

The i18n module has been refactored to load locale data from JSON files instead of the previous INI format, enabling support for nested keys and multiple source files per language. The translation formatting logic has been tightened to prevent unstable behavior when passing slices as arguments to translation functions, now requiring either a single slice or individual arguments. Additionally, the TrHTML function now explicitly escapes string arguments to prevent HTML injection, ensuring that user-provided data is safely rendered within translated HTML templates.

modules/translation/i18n · high confidence

Rewrite markdown rendering engine to Goldmark v2

The markdown rendering engine in modules/markup/markdown has been rewritten to use the Goldmark v2 parser, replacing the previous implementation. This change introduces support for YAML frontmatter (allowing metadata like TOC and language settings), attention blocks (callouts like Note, Warning, Tip), and color previews in code spans. It also improves task list checkbox rendering, math block handling, and code block syntax detection, while adding comprehensive tests for these new features.

modules/markup/markdown · high confidence

Rewritten HTTP library with improved file serving, client request handling, and security hardening

The \modules/httplib\ package has been significantly refactored to improve security, reliability, and feature support. File serving now supports HTTP Range requests, enabling efficient streaming and resumption for large files. Content-Disposition headers are now correctly encoded to handle non-ASCII filenames safely. Security is strengthened by applying strict Content-Security-Policy (CSP) headers to served content, including sandboxing for most file types while allowing necessary styles for PDFs and SVGs. A new client request builder (\ClientRequest\) provides a fluent API for making HTTP requests with configurable timeouts and transports. Additionally, URL handling logic has been updated to prevent open redirect vulnerabilities by strictly validating relative URLs and improving public URL detection behind reverse proxies.

modules/httplib · high confidence

Rewritten logging system with colored output and event-driven writers

The logging module has been completely rewritten to use an event-driven architecture with pluggable writers (console, file, connection) and a centralized manager. Users will now see colored log output in terminals, with HTTP status codes, methods, and response durations color-coded for faster visual parsing. The system supports pausing and resuming log output, expression-based filtering, and automatic fallback to stderr if the configured log file cannot be opened.

modules/log · high confidence

SVG icons are now normalized and cached for rendering

The SVG icon system now normalizes icon content by stripping XML declarations, comments, and redundant attributes, while enforcing consistent width, height, and class attributes. Rendered HTML is cached based on icon name, size, and class to improve performance, with a configurable cache limit to prevent memory growth. This change ensures consistent visual output and faster rendering of icons across the application.

modules/svg · high confidence

Terraform state package deletion restrictions and management

The system now enforces specific constraints on Terraform state packages: users cannot delete a locked state, nor can they delete the latest version of a state. Additionally, the package view now displays lock status information for the latest version. These changes are implemented via new specialization logic in the package service layer. Also in this area: 2 commits (2 fixes) fixing services/packages/terraform.

services/packages/terraform · medium confidence · unverified

Unified Redis and LevelDB connection management with URI support

The NoSQL module now provides a centralized connection manager that supports both Redis and LevelDB through standardized URI formats. Users can configure Redis using standard URIs (including support for clusters, sockets, and sentinels) and LevelDB using URI-style paths with query parameters for options like compression and cache settings. Legacy connection string formats are automatically converted to the new URI scheme, ensuring backward compatibility while enabling more flexible configuration options for both database backends.

modules/nosql · high confidence

Update checker now persists remote version in application state

The update checker module has been refactored to store the latest available Gitea version in the application state (via system.AppState) instead of relying on database context calls. This change ensures that the remote version information is cached and accessible across the application, allowing the system to reliably determine if an update is needed by comparing the stored remote version against the current application version.

modules/updatechecker · high confidence

Updated Material Icon theme file icon rules and SVGs

The file icon configuration has been updated to the latest Material Icon theme definitions. The \options/fileicon/material-icon-rules.json\ file now contains the current folder name-to-icon mappings, and \options/fileicon/material-icon-svgs.json\ provides the corresponding SVG icon data. This ensures that repository file and folder icons in the UI reflect the latest design updates from the Material Icon theme library.

options · high confidence

Test coverage

2 commits adding/updating tests in models/secret; Add Playwright end-to-end test suite for admin, editor, events, and explore features; Add SHA-256 Git repository fixtures for testing; Add bare repository fixture with notes and signed tags for testing; Added empty git repository fixture for testing; Added test fixture for commit history with HEAD reset; Added test fixture for git blame ignore-revs support; Added test fixture for git notes in nested trees; Added test fixture for language stats; Added test fixture for merge file status scenarios; Added test fixture for pull request operations; Added test fixture for repository with submodules; Added tests for access token scopes, OAuth2 redirect URI handling, and two-factor authentication; Added tests for avatar generation and email hashing; Added tests for system notice and setting models; Added tests for the internal issues indexer; Added unit tests for the DBFS package; Added unit tests for the paginator skip/take logic; New internal test fixtures loader and consistency checks; New test infrastructure helpers for file, log, and Redis operations.

Dependencies

Replace gobwas/glob dependency with internal glob implementation

The \modules/glob\ package now uses a new internal implementation instead of the external \gobwas/glob\ library. This change introduces a custom glob-to-regex compiler that supports standard glob patterns (including wildcards, character classes, and alternatives) while allowing configurable path separators. The new module provides the same \Match\ functionality as the previous dependency, ensuring consistent pattern matching behavior for users without requiring external library updates.

modules/glob · high confidence

Upgrade Go toolchain to 1.27.1 and update core dependencies

The project now requires the Go 1.27.1 toolchain and updates its Go module dependencies, including significant upgrades to golang.org/x/crypto (v0.57.0), golang.org/x/net (v0.59.0), and go-git (v5.19.2). Frontend tooling has also been updated, with the Node.js minimum version raised to 22.18.0 and the package manager switched to pnpm v12.4.2.

(dependencies) · high confidence

Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

How this codebase got here

Score

  • CAI 47 → 49 (+2.1)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.3) — scores are not directly comparable.

Lenses

  • Code Health 72 → 72 (+0.7)
  • Architecture 72 → 77 (+5.3)
  • Maturity 75 → 78 (+3.3)
  • Readiness 57 → 60 (+3.2)
  • Security 62 → 64 (+1.2)
  • Domain Modelling 44 → 44 (-0.0)
  • Accessibility 39 → 42 (+2.8)
  • Performance 87 → 97 (+10.4)

Resolved (249)

  • ASTTransformer.transformList (cognitive 19) (modules/markup/markdown/transform_list.go)
  • Change-coupling hub: mock_actions.go → ActionRunView.ts, RepoActionView.vue, WorkflowGraph.vue, repo-actions.ts (routers/web/devtest/mock_actions.go)
  • Critical vulnerability: [GHSA redacted] (pnpm-lock.yaml)
  • Dependency pinned to a stale untagged commit: gitea.com/lunny/levelqueue
  • Dependency pinned to a stale untagged commit: github.com/yuin/goldmark-highlighting/v2
  • DiffFile.prepareDiffRenderDetail (cyclomatic 17) (services/gitdiff/gitdiff.go)
  • Documentation: contradicts the code (docs/community-governance.md)
  • Duplicated block (10 lines × 2) (models/user/email_address.go)
  • Duplicated block (10 lines × 2) (routers/api/v1/repo/compare.go)
  • Duplicated block (10 lines × 2) (routers/web/admin/users.go)
  • Duplicated block (10 lines × 2) (routers/web/auth/openid.go)
  • Duplicated block (10 lines × 2) (routers/web/repo/issue.go)
  • Duplicated block (10 lines × 2) (routers/web/user/setting/oauth2_common.go)
  • Duplicated block (10 lines × 2) (services/actions/notifier.go)
  • Duplicated block (10 lines × 3) (routers/api/v1/repo/git_hook.go)
  • Duplicated block (10–11 lines × 2) (services/actions/commit_status.go)
  • Duplicated block (11 lines × 2) (modules/git/repo_index.go)
  • Duplicated block (11 lines × 2) (routers/web/auth/2fa.go)
  • Duplicated block (11 lines × 2) (routers/web/auth/2fa.go)
  • Duplicated block (11 lines × 3) (models/issues/comment_list.go)
  • …and 229 more

New (706)

  • Boundary-crossing change coupling: api.go ↔ package_form.go (routers/api/packages/api.go)
  • Boundary-crossing change coupling: descriptor.go ↔ package_form.go (models/packages/descriptor.go)
  • Boundary-crossing change coupling: issue.go ↔ projects.go (models/project/issue.go)
  • Boundary-crossing change coupling: package.go ↔ package_form.go (routers/api/v1/packages/package.go)
  • Boundary-crossing change coupling: packages.go ↔ package_form.go (modules/setting/packages.go)
  • Change coupling: code.go ↔ search.go (routers/web/explore/code.go)
  • Change coupling: package_form.go ↔ packages.go (services/forms/package_form.go)
  • Change-coupling hub: mock_actions.go → RepoActionView.vue, WorkflowGraph.vue, repo-actions.ts (routers/web/devtest/mock_actions.go)
  • ClassTooLong: GiteaDownloader (services/migrations/gitea_downloader.go)
  • DBIndexer.Index (cognitive 16) (modules/indexer/stats/db.go)
  • Duplicated block (10 lines × 2) (routers/web/admin/packages.go)
  • Duplicated block (10 lines × 2) (routers/web/admin/users.go)
  • Duplicated block (10 lines × 2) (routers/web/repo/issue.go)
  • Duplicated block (10 lines × 2) (routers/web/repo/pull.go)
  • Duplicated block (10 lines × 2) (routers/web/user/setting/oauth2_common.go)
  • Duplicated block (10 lines × 2) (services/issue/issue.go)
  • Duplicated block (10 lines × 2) (services/migrations/codebase.go)
  • Duplicated block (11 lines × 2) (routers/api/packages/terraform/terraform.go)
  • Duplicated block (11 lines × 2) (routers/web/auth/2fa.go)
  • Duplicated block (11 lines × 2) (routers/web/auth/2fa.go)
  • …and 686 more

Changes since last survey

  • 189 commits — 85 feature/other, 104 fixes

By area

  • routers/web — 27 commits
  • (root) — 21 commits
  • options/locale — 14 commits
  • routers/api — 10 commits
  • web_src/js — 8 commits
  • models/issues — 7 commits
  • tests/e2e — 7 commits
  • tests/integration — 7 commits
  • models/repo — 6 commits
  • modules/markup — 6 commits
  • services/actions — 6 commits
  • services/migrations — 6 commits
  • .github/workflows — 5 commits
  • templates/repo — 5 commits
  • models/actions — 4 commits
  • services/repository — 4 commits
  • modules/git — 2 commits
  • modules/packages — 2 commits
  • modules/util — 2 commits
  • modules/web — 2 commits

Notable commits

  • fix: ci(renovate): fix docker image updates with over 1000 tags (#40077)
  • fix: fix(actions): clear commit status links when a run is deleted (#40088)
  • fix: fix(actions): default-branch push discards a due schedule occurrence (#40073)
  • fix: fix(actions): don't pick up jobs of repos with Actions disabled (#40106)
  • fix: fix(actions): drop untrusted Content-Encoding from v1 artifact uploads (#39855)
  • fix: fix(actions): evaluate job if: against needs finished in the same pass (#40126)
  • fix: fix(actions): include previous values in edited payloads (#40179)
  • fix: fix(actions): keep runner_name after ephemeral runner removal (#39725)
  • fix: fix(actions): make Actions API work with repo admin permission (#40174)
  • fix: fix(actions): match pull_request unlabeled on label removal (#40215)
  • fix: fix(actions): run pull_request workflows on the merge commit (#40076)
  • fix: fix(actions): run review-triggered workflows on the pull request head (#40099)
  • fix: fix(api)!: list only open pull requests when no state is given (#40078)
  • fix: fix(api): answer 409 when repository files already exist on disk (#40095)
  • fix: fix(api): edit and delete repository labels by name (#39974)
  • fix: fix(api): honor branch protection force push and allowlist options on create and edit (#39990)
  • fix: fix(api): honor label archive options (#40008)
  • fix: fix(api): keep webhook settings that are omitted in an edit request (#40282)
  • fix: fix(api): keep wiki page name when editing with an empty title (#40153)
  • fix: fix(api): lock and unlock issues as the signed-in user, not the repository owner (#40291)
  • …and 169 more

Architecture

  • Unchanged — 0 containers · 1 contexts · 0 edges

Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

Survey your own repository

go-gitea/gitea was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.

About this page

  • The score is its most recent published measurement, taken on 13 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
  • Measured at commit 53aafd7ee1014375b05af627805631ebfc0cbf6a — the exact code this score is about.
  • Scored under rubric-2026.11.3 — the same rubric and the same method as every other entry in this index.
  • Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.61+preprod-f3449e6eb431.