dependabot/dependabot-core
35.6
Weak · 14 November 2026
171.2k
lines of production code
Ruby
with C#
6
measurements over time
What this system is
Features
Add Bazel package manager support
Introduces the Bazel package manager integration, enabling Dependabot to fetch, parse, check, and update Bazel dependencies. The change registers the necessary Bazel-specific classes (file fetcher, parser, updater, etc.) and configures label details for pull requests, while marking all Bazel dependencies as production dependencies.
bazel/lib/dependabot · high confidence
Add Bun package details fetching and registry resolution
Introduces \PackageDetailsFetcher\ and \RegistryFinder\ classes for the Bun ecosystem. The \PackageDetailsFetcher\ retrieves package metadata (releases, dist-tags, yank status) from npm-compatible registries, enabling features like cooldown checks that require detailed package history. The \RegistryFinder\ resolves the correct registry URL and authentication headers by parsing \.npmrc\, \.yarnrc\, and \.yarnrc.yml\ files, supporting both global and scoped registry configurations.
bun/lib/dependabot/bun/package · high confidence
Add Composer v2 helper implementation
Introduces a new set of PHP classes in composer/helpers/v2 to support Composer v2 operations. This includes an Updater and UpdateChecker that configure the Composer installer to ignore platform requirements and disable auditing, an ExceptionIO class to capture resolution errors, a DependabotPluginManager that suppresses installation failures for specific packages like PHP\_CodeSniffer, and a Hasher utility for generating content hashes from composer.json files.
composer/helpers/v2 · high confidence
Add Conda ecosystem support for checking latest package versions
Dependabot now supports the Conda package manager. This change introduces a new \LatestVersionFinder\ for Conda that determines the latest available versions by querying the Conda registry client, respecting channel priorities (explicit source, requirement prefix, environment file, and defaults). For dependencies marked as pip-compatible, it delegates to the existing Python version finder by translating Conda requirements into pip-compatible formats using a new \RequirementTranslator\ (handling wildcards, exact versions, and comparisons). This enables version updates for Conda packages within the dependency update workflow.
_conda/lib/dependabot/conda/update\checker · high confidence
Add Deno ecosystem support
Dependabot now supports the Deno ecosystem, enabling automatic dependency updates for projects using deno.json or deno.jsonc manifests. This includes parsing imports from both the JSR and npm registries, resolving workspace member directories (including glob patterns), and updating both manifest files and deno.lock lockfiles by regenerating the lockfile via the deno CLI. The implementation handles Deno-specific versioning (semver with build metadata), constraint conversion (caret, tilde, exact), and source lookups for npm packages.
(repo-wide) · high confidence
Add VS Code Remote Development on Docker
Developers can now use VS Code Remote Containers to work in a pre-configured Ubuntu environment. The setup includes the .NET SDKs (8.0, 9.0, and 10.0), Ruby 4.0.5, Node.js, Go, and Rust. It also installs the Dependabot CLI, configures Ruby formatting tools, and pre-pulls the Dependabot proxy image to speed up startup.
.devcontainer · high confidence
Add initial support for the Bun package manager
Introduces a new independent ecosystem for the Bun runtime, enabling Dependabot to fetch, parse, and update Bun-specific dependency manifests (package.json) and lockfiles. This change registers Bun as a distinct package manager with its own file fetcher, parser, and update logic, separate from the existing npm and yarn implementations, and includes error handling for Bun-specific issues such as Node version mismatches and registry access failures.
bun/lib/dependabot · high confidence
Add native Bundler 4 helper tree
Introduces a dedicated native helper implementation for Bundler 4 in the \bundler/helpers/v4\ directory. This new tree includes a build script to install and isolate Bundler 4, a runtime entry point (\run.rb\) that activates the correct version, and a suite of Ruby modules (\lib/functions\) that expose dependency resolution, lockfile updating, and source detection capabilities. It also incorporates monkey patches to handle Bundler 4-specific API changes, such as converting SSH git URLs to HTTPS and tolerating empty checksum metadata from registries.
bundler/helpers/v4 · high confidence
Add native Conda ecosystem support
Dependabot now natively supports the Conda package manager, enabling it to detect, update, and provide metadata for dependencies in \environment.yml\ and \environment.yaml\ files. This feature includes fetching package metadata from the Anaconda API, parsing Conda-specific version constraints (including channel prefixes and bracket syntax), and updating dependency specifications in manifest files. It also supports pip dependencies listed within Conda environments by delegating to the existing Python metadata finder.
conda/lib/dependabot/conda · high confidence
Added Deno ecosystem support configuration
A new configuration file has been added to the Deno bundle directory, pointing the bundle gemfile to the project's main Gemfile. This change enables the system to manage dependencies for the Deno ecosystem using the existing Ruby-based dependency management setup.
deno/.bundle · medium confidence
Bazel ecosystem support added to update checker
Added a new RegistryClient for the Bazel ecosystem that fetches module metadata and versions from the bazelbuild/bazel-central-registry GitHub repository. This enables Dependabot to check for updates to Bazel modules by retrieving available versions, source files, and release dates directly from the central registry.
_bazel/lib/dependabot/bazel/update\checker, maven · high confidence
Bazel ecosystem support and Bun ecosystem separation
Added support for the Bazel ecosystem, including fetching .bzl files, MODULE.bazel includes, and directory trees. Separated Bun from npm\_and\_yarn as an independent ecosystem, introducing its own lockfile generator, package.json updater, registry parser, and vulnerability auditor.
dependabot-core · high confidence
Bundler package manager integration registered
The bundler package manager is now officially supported. This change registers the necessary Bundler-specific classes (such as file fetcher, parser, and updater) and configures the system to identify Bundler projects, including a specific rule for determining production dependencies based on runtime, default, or prod groups.
bundler/lib/dependabot · high confidence
Cargo package manager support initialization
The Dependabot system now includes the core entry point for the Cargo package manager. This change registers the necessary Cargo-specific components (file fetcher, parser, updater, etc.) and configures the system to automatically label pull requests for Rust dependencies with a 'rust' label. It also establishes a default production check for Cargo dependencies, treating them as production dependencies by default.
cargo/lib/dependabot · high confidence
Composer package manager integration initialized
The Composer package manager is now supported, enabling Dependabot to fetch, parse, update, and find metadata for PHP projects using Composer. This integration registers the 'composer' manager with specific label details (PHP, color \#45229e) for pull requests and defines a production dependency check that identifies dependencies in the 'runtime' group as production.
composer/lib/dependabot · high confidence
Dev container bundle configuration added
A new configuration file has been added to the devcontainers/.bundle directory that sets the BUNDLE\_GEMFILE environment variable to point to the Gemfile located in the ../dependabot-updater directory, establishing the Ruby dependency context for the dev container environment.
devcontainers/.bundle · high confidence
Docker ecosystem support now includes Kubernetes YAML and Helm chart parsing
The Docker file parser has been updated to also scan Kubernetes YAML files and Helm chart values files for container image references, in addition to standard Dockerfiles and Containerfiles. This means Dependabot will now detect and propose updates for images defined in Kubernetes manifests and Helm configuration files within the same repository, broadening the scope of automated container image updates.
docker/lib/dependabot/docker · high confidence
Go modules ecosystem restructured with native helpers and Go workspace support
The go\_modules ecosystem has been reorganized into a standalone directory structure, introducing a Go-based native helper binary to handle VCS remote resolution (including Azure DevOps URL normalization) and version sorting. This change adds support for Go workspaces (go.work files) in the file fetcher and parser, and updates the Dockerfile to build the Go 1.27 toolchain alongside the native helpers. The Ruby implementation now uses Sorbet for strict typing and registers the ecosystem's file fetcher, parser, updater, and dependency grapher within the new modular layout.
_go\modules · high confidence
Initial Bazel ecosystem support for MODULE.bazel and WORKSPACE
Dependabot now supports the Bazel ecosystem, enabling dependency updates for projects using both the legacy WORKSPACE system and the modern bzlmod MODULE.bazel system. The implementation includes file fetching for MODULE.bazel, WORKSPACE, BUILD, and associated lockfiles (.bazel.lock), as well as parsing and updating dependencies declared via bazel\_dep() and http\_archive(). It also handles Bazel-specific versioning nuances, such as preserving hyphenated pre-release formats and managing .bcr.N suffixes, with a default Bazel version of 8.5.1.
bazel/lib/dependabot/bazel · high confidence
Initial Swift ecosystem support for Dependabot
Dependabot now supports the Swift Package Manager (SPM) ecosystem. This change introduces the core infrastructure to fetch, parse, check for updates, and update Swift dependencies. It supports both classic SPM projects (using \Package.swift\ and \Package.resolved\) and Xcode-managed SwiftPM projects (using \project.pbxproj\ and \Package.resolved\ within \.xcodeproj\ or \.xcworkspace\ directories). The implementation includes a Dockerfile with Swift 6.3.1, Sorbet-typed Ruby classes for file fetching, parsing, updating, and metadata finding, and support for SemVer versioning and requirement parsing.
swift · high confidence
Initial implementation of the Cargo ecosystem support
Dependabot now supports the Rust/Cargo ecosystem. This change introduces the core components required to manage Rust dependencies, including a file fetcher that retrieves \Cargo.toml\, \Cargo.lock\, and workspace or path dependencies; a file parser that extracts dependency metadata from manifests and lockfiles; an update checker that handles version resolution and security fixes; and a file updater that modifies manifests and lockfiles. It also includes a metadata finder for crates.io and custom registries, a version class that correctly implements Cargo's pre-1.0 semantic versioning rules, and a requirement class that parses Rust-specific version constraints. Additionally, it provides helpers to sanitize Cargo configuration files and manage registry authentication.
cargo/lib/dependabot/cargo · high confidence
Initial support for Conda package management
Dependabot now supports Conda as a package manager. This change registers the Conda ecosystem, including file fetching, parsing, updating, and metadata finding, and configures label coloring and dependency production checks for Conda packages (including those from pip/PyPI within Conda environments).
conda/lib/dependabot · high confidence
Initial support for Dart (pub) dependency updates
Dependabot now supports updating Dart projects that use the pub package manager. This change introduces the core ecosystem implementation, including file fetching for pubspec.yaml and pubspec.lock, parsing of dependencies via the pub dependency services interface, and updating of project files. It also includes native helper scripts for inferring Flutter SDK versions and a Dockerfile that installs the Dart SDK (version 3.10.0) to run these helpers.
pub · high confidence
Initial support for Julia dependency updates
Dependabot now supports updating Julia projects by parsing \Project.toml\ and \Manifest.toml\ files, resolving dependencies via Julia's Pkg manager, and fetching versions from the General registry. The update process runs inside a Docker container pinned to Julia 1.13, using a native Julia helper (\DependabotHelper.jl\) to handle complex resolution logic. This initial release includes support for Julia workspaces (multiple packages sharing a manifest), standard library compatibility derivation, and yanked version filtering.
julia · high confidence
Initial support for Nix flake dependency updates
Dependabot now supports updating Nix flake dependencies. This adds a new Nix ecosystem that parses \flake.nix\ and \flake.lock\ files to detect git-based inputs (GitHub, GitLab, Sourcehut, and generic git) and NixOS channel tarballs. The updater can modify flake inputs to point to newer revisions or channel versions, and the system handles channel tarball compression suffixes (xz, gz, bz2, zst) and indirect input references.
nix · high confidence
Initial support for the SBT ecosystem
Dependabot now supports the SBT build tool for Scala projects. This change introduces the core infrastructure for the SBT ecosystem, including a Dockerfile that installs the JDK and Coursier (SBT's dependency resolver), and a suite of Ruby classes that implement the standard Dependabot pipeline: fetching \build.sbt\ and related files, parsing dependencies (including cross-versioned \%%\ dependencies and property-based version references), checking for available updates against Maven repositories, and updating the build files. It also includes native helper scripts to ensure Coursier is available in the runtime environment.
devcontainers/lib/dependabot, devcontainers/lib/dependabot/devcontainers, sbt · high confidence
Initial support for the uv Python package manager
Dependabot now supports managing dependencies for Python projects using the \uv\ tool. This change introduces a new \uv\ ecosystem that detects and updates \uv.lock\ files and \pyproject.toml\ configurations, including support for workspace members, PEP 621/735 dependency groups, and path dependencies. The implementation includes a dedicated Dockerfile with pre-compiled Python versions and the \uv\ binary, native helper scripts for parsing requirements, and Sorbet-typed Ruby classes for file fetching, parsing, and dependency graphing.
uv · high confidence
Initial support for the vcpkg C++ package manager
Dependabot now supports updating C++ dependencies managed by vcpkg. This adds a new updater ecosystem that parses \vcpkg.json\ and \vcpkg-configuration.json\ manifests to track ports and registry baselines. Users can now receive automated updates for port version constraints (\version\>=\), the built-in registry baseline, and custom registries. The implementation includes security update support driven by OSV advisories, with remediation strategies that raise baselines, add version constraints, or apply overrides as needed. The updater runs in a dedicated container image that includes the vcpkg CLI and a checkout of the official vcpkg registry to resolve versions.
vcpkg · high confidence
Initial support for updating .NET SDK versions via global.json
Dependabot can now detect and update the .NET SDK version specified in a repository's \global.json\ file. This new \dotnet\_sdk\ ecosystem parses the \sdk.version\ field, fetches the latest available SDK releases from the official Microsoft release metadata index, and updates the \global.json\ file with the new version. The implementation handles UTF-8 BOM characters in configuration files, preserves prerelease versions if explicitly allowed in the configuration, and provides metadata linking to the .NET SDK GitHub repository.
_dotnet\sdk · high confidence
Initial support for updating Rust toolchain files
Dependabot now supports the \rust\_toolchain\ ecosystem, enabling automatic updates for \rust-toolchain\ and \rust-toolchain.toml\ files. This new updater detects the current toolchain channel (such as \stable\, \beta\, \nightly\, or specific version numbers like \1.72.0\) and proposes updates to the latest available version from the Rust release manifests. It handles various channel types, including dated stability releases, and registers the necessary file fetcher, parser, and updater components to manage these dependencies.
_rust\toolchain · high confidence
Initialize Sorbet type checking with RBI definitions and configuration
This change introduces Sorbet static type checking to the codebase. It adds a \sorbet/config\ file to define the check scope and ignore patterns for spec directories, and populates \sorbet/rbi/\ with generated RBI files for internal gems (such as \addressable\, \ast\, and AWS SDKs) and annotations for external libraries (like \faraday\, \rainbow\, and \webmock\). This setup enables the toolchain to verify type correctness across the project.
sorbet · high confidence
Introduce .NET SDK package correlation for transitive dependency updates
The NuGet updater now includes a new \DotNetPackageCorrelation\ tool and library that parses .NET SDK release notes to map runtime packages to their corresponding SDK packages. This capability allows the updater to identify and update transitive dependencies that are implicitly referenced by the .NET SDK, ensuring that updates to SDK packages correctly propagate to their associated runtime packages.
nuget/helpers · high confidence
Introduce Bun as a standalone ecosystem
Dependabot now supports the Bun package manager as an independent ecosystem, separate from npm and yarn. This change adds the core implementation files for the Bun ecosystem, including a file fetcher to retrieve package.json and bun.lock files, a file parser to extract dependencies, a file updater to modify manifests and lockfiles, and a dependency grapher to map sub-dependencies. It also introduces a version manager to track supported Bun versions (starting from 1.1.39) and lockfile formats, along with helper modules for constraint parsing and version detection.
bun/lib/dependabot/bun · high confidence
Introduce Bun ecosystem support with native update checking and resolution
This change adds the core update-checking infrastructure for the Bun package manager, including a new DependencyFilesBuilder to prepare temporary project files, a LibraryDetector to identify library packages, and a VersionResolver that handles peer dependency conflicts and version resolution. It also introduces a PackageLatestVersionFinder that applies cooldown logic to filter releases, ensuring that update checks for Bun dependencies behave consistently with existing npm/yarn ecosystems while respecting Bun-specific lockfiles and registry configurations.
_bun/lib/dependabot/bun/update\checker · high confidence
Introduce Composer v2 native helper implementation
A new Composer v2 native helper is added under composer/helpers/v2, providing a standalone PHP entry point (bin/run) that reads update requests from stdin and invokes the Updater, UpdateChecker, and Hasher components. The helper includes a build script that copies source files, runs Composer install, and executes linting and static analysis, alongside configuration files for PHP CS Fixer and PHPStan to enforce code quality standards.
composer/helpers · high confidence
Introduce Dependency Graphers for structured dependency submission
A new Dependency Graphers component has been added to convert parsed dependencies into a generic data structure compatible with GitHub's Dependency submission API. This includes a \Base\ class with support for manifest grouping (allowing ecosystems with multiple independent manifests to split resolution) and a \Generic\ fallback implementation that maps package managers to Package-URLs (PURLs) and handles subdependency fetching. The system ensures that errors during subdependency resolution are propagated and absorbed, providing a robust foundation for future ecosystem-specific graphers.
_common/lib/dependabot/dependency\graphers · high confidence
Introduce Docker Compose support for fetching, parsing, and updating compose files
This change adds the core implementation for the Docker Compose ecosystem, enabling Dependabot to detect, analyze, and update docker-compose.yml files. The new FileFetcher identifies compose files by name, the FileParser extracts image dependencies from service definitions (including handling inline Dockerfiles and environment variable defaults), and the FileUpdater modifies image tags in the YAML files. This allows users to receive dependency updates for their Docker Compose-based projects.
_docker/lib/dependabot/docker\compose · high confidence
Introduce GitHub Actions ecosystem support with lockfile relocking
Dependabot now supports updating GitHub Actions dependencies. This adds a new \github\_actions\ package manager that parses workflow files, checks for updates, and updates references. A key addition is the integration with the \gh-actions-lock\ tool: when an \actions.lock\ file is present, Dependabot will relock it to ensure consistency after updating workflow files. The implementation includes file fetching, parsing, updating, and metadata finding for GitHub Actions, along with support for composite actions and reusable workflows.
_github\actions · high confidence
Introduce Helm ecosystem support for Dependabot
Dependabot now supports automated dependency updates for Helm charts. This change adds the full Helm ecosystem implementation, including file fetching for Chart.yaml and values.yaml, parsing of Helm chart dependencies and Docker images referenced in values, and updating of chart constraints and image tags. It also introduces a custom Helm version class and requirement parser to handle Helm-specific SemVer ranges, along with OCI registry support and a release cooldown feature to filter out recently published versions.
helm · high confidence
Introduce Julia language support via DependabotHelper.jl
Added a new Julia helper module that enables Dependabot to discover, parse, and update Julia dependencies. The helper processes Project.toml and Manifest.toml files (including Julia-specific naming conventions like JuliaProject.toml and versioned manifests), resolves package metadata and available versions from registries (filtering yanked releases), and manages custom registries with a time-to-live refresh strategy. It also handles Julia standard library versioning by deriving compatible stdlib versions from the project's Julia compatibility range, supports Julia workspaces by discovering member projects, and provides batched API calls for performance.
julia/helpers/DependabotHelper.jl · high confidence
Introduce OpenTofu ecosystem support
Adds a new OpenTofu ecosystem to Dependabot, enabling the detection and updating of OpenTofu modules and providers. This includes file fetching for .tf and .tofu files, parsing of module and provider dependencies (including local paths and Terragrunt), version checking against the OpenTofu registry and OCI sources, and updating of configuration files and lockfiles. The implementation supports both public and private registries, handles local variable references in version constraints, and integrates with the existing Dependabot infrastructure for PR creation and labeling.
opentofu · high confidence
Introduce Pre-Commit ecosystem support with additional dependencies updates
Adds a new Pre-Commit ecosystem to Dependabot, enabling the detection and updating of pre-commit hook revisions. The implementation includes a registry-based architecture for parsing and checking 'additional\_dependencies' across multiple languages (Python, Node, Go, Ruby, Dart, Rust), delegating to existing ecosystem-specific update checkers. It also supports extracting version comments from frozen SHA references and includes a dedicated Dockerfile for building the updater image with necessary native helpers.
_pre\commit · high confidence
Introduce PullRequestUpdater implementations for Azure, GitLab, and GitHub
This change adds new \PullRequestUpdater\ classes for Azure DevOps, GitLab, and GitHub, moving the logic for updating pull request branches into the common library. These implementations allow Dependabot to update existing pull requests with new dependency changes across all three supported providers, handling provider-specific details such as branch protection rules, commit signing (GitHub), and merge request source branch updates (GitLab).
_common/lib/dependabot/pull\_request\updater · high confidence
Introduce base file fetcher with repository cloning and submodule support
Adds a new \Dependabot::FileFetchers::Base\ class that enables fetching dependency files by cloning the entire source repository into a local directory (\repo\_contents\_path\) rather than relying solely on individual API calls. This change introduces support for handling Git submodules (including recursive cloning and error handling for inaccessible submodules), resolves symlinks within the cloned tree, and strips UTF-8 BOMs from file contents to ensure correct parsing. It also implements path exclusion filtering via \exclude\_paths\ and provides a robust retry mechanism for transient Git clone errors, improving reliability for large repositories or those with complex directory structures.
_common/lib/dependabot/file\fetchers · high confidence
Introduce generic package version finding with npm-specific parsing and cooldown support
Adds a new \PackageLatestVersionFinder\ base class in the common library to standardize how package versions are discovered, replacing ecosystem-specific logic with a unified interface. This change introduces typed models for npm artifacts (\NpmPackageJson\, \NpmLockfileDetails\, \NpmPackageManagerConfig\, \NpmRegistryPackage\) to safely parse \package.json\ and registry metadata, including handling legacy repository arrays and peer dependencies. It also implements a \CooldownDateTracker\ that allows package managers to filter out recent releases based on configurable cooldown periods, with a fallback to the current version if all candidates are excluded, and adds support for tracking unavailable cooldown dates.
common/lib/dependabot/package · high confidence
Introduce shared Docker file processing components
Added three new abstract base classes—SharedFileFetcher, SharedFileParser, and SharedFileUpdater—to the docker shared library. These components provide a unified foundation for fetching, parsing, and updating Dockerfiles and Kubernetes YAML manifests, including logic to strip byte-order marks (BOM) from YAML files and handle image digest pinning.
docker/lib/dependabot/shared · high confidence
Introduce standalone Git Submodules ecosystem support
This change extracts the Git Submodules logic into a dedicated \git\_submodules\ directory, providing a complete, isolated implementation for Dependabot. It includes the core components: a \FileFetcher\ to retrieve \.gitmodules\ and submodule references, a \FileParser\ to extract dependencies (including handling relative URLs and rejecting trailing slashes), an \UpdateChecker\ with a \LatestVersionFinder\ that prioritizes tagged releases over commits and respects cooldown options, a \FileUpdater\ to modify the \.gitmodules\ file, and a \MetadataFinder\. The implementation is fully typed with Sorbet, includes a dedicated \Version\ and \Requirement\ class, and is supported by a comprehensive test suite covering GitHub, GitLab, and Azure sources.
_git\submodules · high confidence
Introduce standalone Terraform ecosystem implementation
The Terraform ecosystem support has been extracted from the core Dependabot codebase into a dedicated, standalone \terraform\ directory. This change introduces a complete, self-contained implementation including the FileFetcher, FileParser, FileUpdater, UpdateChecker, and MetadataFinder, along with native helper scripts for the HCL2 parser. The new structure includes a Dockerfile to build the Terraform CLI binary (version 1.16.4) and the \hcl2json\ tool, Sorbet type signatures for all components, and specific logic for handling Terraform lockfiles, Terragrunt files, and private registry authentication.
gradle, terraform · high confidence
Introduce typed core data models and configuration classes
Added strongly typed Sorbet models for core domain concepts: \Credential\ (with scope and base-replacement logic), \Dependency\ (with directory, subdependency metadata, and attribution fields), \DependencyFile\ (with operation, mode, and symlink support), and \ErrorDetails\. Also added \Config::InvalidConfigError\, \DependencyGraphers\ registry, and \FileFiltering\ logic for \exclude-paths\ support.
common/lib/dependabot · high confidence
Introduces dedicated Cargo package details fetcher
Adds a new \PackageDetailsFetcher\ class for the Cargo ecosystem that retrieves package metadata from the Crates.io API (including both standard and sparse index formats). This component handles authentication for private registries, parses version listings to extract release dates and download counts, and constructs structured package details for Dependabot to process.
cargo/lib/dependabot/cargo/package · high confidence
Introduction of MetadataFinders module with typed base implementation
A new MetadataFinders module has been added to the common library, providing a standardized way to retrieve dependency metadata such as source URLs, changelogs, releases, and commit history. The implementation includes a strongly typed base class (Dependabot::MetadataFinders::Base) that handles memoization of finder components (ChangelogFinder, ReleaseFinder, CommitsFinder) and exposes a public API for integration. The base class also introduces logic to append directory paths to source URLs for package managers with reliable directory structures (bun, npm\_and\_yarn, pub) and defines overridable methods for detecting maintainer, install script, and attestation changes.
_common/lib/dependabot/metadata\finders · high confidence
Introduction of the Dependabot Omnibus Gem
The new \omnibus\ gem provides a single entry point that aggregates and requires all supported ecosystem updaters (such as Bundler, npm, Docker, Go, Python, and others). This allows consumers to load the entire suite of dependency update capabilities with a single require statement, simplifying integration and ensuring all ecosystem definitions are available.
omnibus · high confidence
Native JavaScript helpers for Bun ecosystem support
This change introduces a new directory of native JavaScript helper functions for the Bun ecosystem, mirroring the existing npm, yarn, and pnpm helpers. These helpers are written in JavaScript to leverage package manager internal APIs and are invoked by the Ruby codebase via \run.js\, passing arguments through stdin and returning JSON to stdout. The implementation includes a build script to install dependencies and copy the helpers, along with configuration files for ESLint and Jest. Specific modules are provided for parsing lockfiles (pnpm), auditing vulnerabilities and resolving conflicting dependencies (npm), and updating dependencies, checking peer dependencies, and resolving conflicts (yarn).
bun/helpers · high confidence
Native TypeScript helpers for npm, yarn, and pnpm
The npm\_and\_yarn ecosystem now uses native TypeScript helpers to perform package manager operations, replacing previous Ruby-based implementations. These helpers, built into the Docker image and executed via a standardized stdin/stdout interface, provide improved performance and reliability for tasks such as parsing lockfiles, resolving peer dependency conflicts, auditing vulnerabilities, and updating dependency files. The Dockerfile has been updated to include Node.js 24, npm 11.17.0, pnpm 12.10.1, and Yarn 4.18.0, with Corepack managing the package manager versions.
_npm\_and\yarn · high confidence
New Bundler 2 dependency resolution and update helpers
The bundler helpers now include a suite of new classes to manage dependency resolution and updates for Bundler 2. These include \ConflictingDependencyResolver\ to identify sub-dependency conflicts, \DependencySource\ to determine gem sources (Rubygems, Git, private registry), \FileParser\ to parse Gemfile and lockfile contents, \ForceUpdater\ to force-update specific dependencies, \LockfileUpdater\ to regenerate lockfiles with vendored gem caching, and \VersionResolver\ to determine the latest resolvable version of a dependency. These changes improve the accuracy and robustness of dependency updates in Bundler 2 environments.
bundler/helpers/v2/lib/functions · high confidence
New Bundler PackageDetailsFetcher with private registry and cooldown support
A new \PackageDetailsFetcher\ class has been introduced for the Bundler ecosystem to handle dependency metadata retrieval. This implementation adds support for private registries by allowing credential-based authentication and includes logic to return \nil\ for dependencies sourced from 'git' or 'other' rather than falling back to rubygems.org. It also integrates with the bundler cooldown functionality, supporting both standard Rubygems API responses and Compact Index v2 publication dates to manage rate limiting effectively.
bundler/lib/dependabot/bundler/package · high confidence
New build and development scripts for modular updater ecosystem
The repository now includes a set of new shell and Ruby scripts in the \script/\ directory to support the decoupling of updater ecosystems into independent Docker images. \script/build\ and \script/\_common\ provide a unified interface for building specific ecosystem images (e.g., \bundler\, \npm\_and\_yarn\) using Docker BuildKit, with support for GitHub Actions cache backends and handling of Docker API version mismatches. \script/dependabot\ mounts the local filesystem into a container to allow interactive debugging of the CLI against various ecosystem directories. \script/ci-test-updater\ runs updater specs inside the built container, while \script/updater-e2e\ executes end-to-end Go tests for the updater logic. Additional scripts include \script/setup\ for authenticating with GitHub Packages, \script/generate-coverage-report\ for Sorbet type-coverage analysis, \script/sorbet-untyped-ratchet\ to prevent regression in \T.untyped\ exclusions, and \script/test-rakefile\ for Rake task integration testing.
script · high confidence
New changelog and release metadata finders for Dependabot
Dependabot now includes dedicated classes for finding and processing changelogs and release notes across supported providers (GitHub, GitLab, Bitbucket, Azure). The new ChangelogFinder locates changelog files by name (e.g., CHANGELOG, NEWS, HISTORY) and prunes them to show only relevant version sections, while the ReleaseFinder aggregates release information from provider APIs. These components improve the accuracy and reliability of changelog and release data displayed in Dependabot pull requests.
_common/lib/dependabot/metadata\finders/base · high confidence
New common library with version constant and wildcard matching utility
The common/lib area now includes the main Dependabot module defining the current version (0.399.0) and a new WildcardMatcher class that allows users to match strings against wildcard patterns (e.g., 'v1.\*') using case-insensitive regular expressions.
common/lib · high confidence
New dependency parsing and hashing utilities for Python projects
Added new helper modules in uv/helpers/lib to parse PEP 621 and PEP 735 dependency groups from pyproject.toml files, including support for optional dependencies, build-system requirements, and UV-specific path sources. The new hasher module provides functions to compute dependency hashes using hashin, as well as to extract hashes from Pipfile and Poetry lock files, with specific error handling for SSL certificate verification failures.
uv/helpers · high confidence
New development and release helper scripts
Added several new scripts to the bin directory to streamline development workflows and release processes. bin/dry-run.rb allows developers to simulate full update runs for a given repository and package manager without creating pull requests, supporting a wide range of ecosystems and options like security advisories and blocked versions. bin/docker-dev-shell provides an interactive Docker development environment, building per-ecosystem images and mounting necessary source files and helpers. bin/test simplifies running tests within the Docker development image for specific ecosystems. bin/bump-version.rb automates version updates for the common library and associated Gemfile.locks. Additional scripts include bin/ci-test for simulating CI processes, bin/lint for running shellcheck and rubocop, and wrappers for rubocop and tapioca.
bin · high confidence
New rake tasks to scaffold and configure new ecosystems
Developers can now use \rake ecosystem:scaffold\[\<name\>\]\ to generate the boilerplate structure (library files, specs, Dockerfile, gemspec) for a new ecosystem, and \rake ecosystem:update\_infrastructure\[\<name\>\]\ to automatically register it in CI workflows, gemspec lists, and updater configuration. A combined \rake ecosystem:create\[\<name\>\]\ task runs both steps sequentially. The scaffolder supports \ask\, \skip\, and \force\ overwrite modes to handle existing files safely.
rakelib · high confidence
New typed API clients and retry middleware for Azure, Bitbucket, and GitLab
This change introduces new, strictly typed API client wrappers for Azure DevOps, Bitbucket, and GitLab in the common library, along with retry-enabled proxy classes (e.g., \BitbucketWithRetries\, \GitlabWithRetries\) that automatically retry on connection failures. It also adds a \GithubRelease\ struct and \GithubResourceParser\ module to safely parse GitHub API responses, and a \JsonResponseParser\ module for consistent JSON handling across clients. These components provide a more robust, type-safe foundation for interacting with these version control systems.
common/lib/dependabot/clients · high confidence
Newly introduced file parser base class and documentation
This change introduces the \Dependabot::FileParsers::Base\ class and its accompanying README documentation within the \common/lib/dependabot/file\_parsers\ directory. The base class provides a strongly typed foundation (using Sorbet) for all language-specific file parsers, defining the public API contract including \\#parse\ and \\#check\_required\_files\, and exposing attributes for dependency files, source, credentials, and options. It also introduces utility methods such as \dealias\_packages!\ for handling aliased packages and \run\_in\_parsed\_context\ for ecosystem-specific native command execution. The new README documents the public API and provides guidance for implementing new parsers, establishing the structural standard for how dependency files are extracted into \Dependabot::Dependency\ instances.
_common/lib/dependabot/file\parsers · high confidence
Python ecosystem support restructured with native helpers and PEP 735 parsing
The Python ecosystem module has been reorganized into a standalone \python\ directory, introducing a new native helper system (\python/helpers\) that executes Python scripts (like \run.py\) to parse requirements, setup files, and pyproject manifests. This change adds support for PEP 735 dependency groups in \pyproject.toml\ and improves the handling of PEP 621 projects. The \DependencyGrapher\ now supports layering for pip/pip-compile projects, correctly filtering bystander \.txt\ files while preserving constraint and include references. Additionally, the module registers specific label details for the 'pip' package manager and implements a name normalizer for Python packages.
python · high confidence
Support for Bzlmod lockfile generation and Bazel workspace updates
Dependabot now supports updating Bazel dependencies in both the legacy WORKSPACE files and the newer Bzlmod system. For Bzlmod projects, Dependabot updates MODULE.bazel files and automatically regenerates the MODULE.bazel.lock lockfile by running 'bazel mod tidy', using a default Bazel version if a .bazelversion file is not present. For legacy WORKSPACE files, it updates http\_archive and git\_repository declarations, including transforming version strings in URLs. The lockfile updater now raises specific errors if Bazel is not found or if dependencies cannot be resolved, rather than silently falling back.
_bazel/lib/dependabot/bazel/file\updater · high confidence
Support for dependency group and multi-ecosystem branch naming strategies
Users can now generate branch names for updates involving multiple dependencies grouped together or spanning multiple ecosystems. This change introduces two new strategies, \DependencyGroupStrategy\ and \MultiEcosystemStrategy\, which create deterministic branch names by appending a 10-character MD5 digest of the dependency changes to the group or ecosystem name. These strategies support the same configuration options as existing strategies, including custom prefixes, separators, word separators, case formatting, and max length constraints, and they also support custom branch name templates. This allows for more predictable and manageable branch names when Dependabot handles complex updates involving multiple packages or ecosystems simultaneously.
_common/lib/dependabot/pull\_request\_creator/branch\namer · high confidence
Support for private Docker registries and Helm chart detection
Users can now configure private Docker registries (including AWS ECR) with authentication credentials, allowing Dependabot to check for updates in private repositories. Additionally, the system now automatically detects Helm chart values files (matching patterns like \values.yaml\ or \values-\*.yaml\) to support Helm-based dependency management.
docker/lib/dependabot/shared/utils · high confidence
Removals
Removal of Dependency and RubyFileParser classes
The \Dependency\ class and the \RubyFileParser\ (which previously used the \gemnasium/parser\ library to parse Gemfiles) have been removed from the \lib/bumper\ library. This eliminates the existing mechanism for parsing Ruby dependency files and representing them as dependency objects.
lib/bumper · high confidence
Architecture
Pull request creation logic and branch naming standardized in common library
The pull request creation implementations for Azure, Bitbucket, CodeCommit, GitHub, and GitLab, along with the branch namer and message builder, have been moved into the common library with strict Sorbet typing. This change centralizes the core logic for creating pull requests and generating branch names across all supported providers, ensuring consistent behavior and type safety for the underlying mechanics of PR creation.
_common/lib/dependabot/pull\_request\creator · high confidence
Strict typing added to RequirementsUpdater base interface
The \RequirementsUpdater\ module now includes a strictly typed base interface (\Base\) using Sorbet. This interface defines abstract methods for \updated\_requirements\, \version\_class\, and \requirement\_class\, ensuring that all concrete updater implementations (such as those for Gradle, Maven, and SBT) adhere to a consistent type contract for handling dependency requirements.
_common/lib/dependabot/requirements\updater · high confidence
Behavioural changes
1 commit (0 fixes) modifying bundler/helpers/v2/sorbet
A change to existing behaviour in bundler/helpers/v2/sorbet — 1 commit, 1 file: “Enable Sorbet checking for Bundler v2 helper specs (\#16777)” (refs \#16777).
bundler/helpers/v2/sorbet · medium confidence · unverified
4 commits (0 fixes) modifying apm
A change to existing behaviour in apm — 4 commits, 46 files: “Add apm (Agent Package Manager) ecosystem support (\#16382)”; “Add support for apm lockfile regeneration and pinning deps to commit sha (\#16514)”; “Enable Sorbet checking for APM specs (\#16710)”; and 1 more (refs \#16382, \#16514, \#16710, \#16885).
apm · medium confidence · unverified
Add dedicated Bun lockfile parser with version and config validation
Dependabot now includes a dedicated parser for \bun.lock\ files, replacing the previous shared \npm\_and\_yarn\ handling. This new implementation validates the \lockfileVersion\ against the maximum version supported by the bundled Bun binary and preserves the \configVersion\ field (introduced in Bun v1.3.2) to ensure install defaults remain stable. The parser correctly handles JSONC syntax via YAML loading and extracts dependency details from the lockfile's package records.
_bun/lib/dependabot/bun/file\parser · high confidence
Bun ecosystem support now runs install commands with --ignore-scripts
The Bun file updater now executes \bun install\ and \bun update\ commands with the \--ignore-scripts\ flag. This change prevents lifecycle scripts defined in package dependencies from running during the update process, which can improve security and stability by avoiding unexpected side effects or build failures during automated dependency updates. Also in this area: Bun workspace dependency updates are now scoped to specific workspaces.
_bun/lib/dependabot/bun/file\updater · high confidence
Bundler ecosystem support upgraded to include Bundler 4 and native subprocess helpers
The Bundler file fetcher, parser, and updater now support Bundler 4 alongside Bundler 2, with Bundler 1 explicitly removed from supported versions. A new native helper architecture is introduced to run Bundler operations in isolated subprocesses, allowing for better isolation and the enforcement of source cooldowns. The system now also detects and fetches \.tool-versions\ files, and the metadata finder has been updated to request gzip-compressed responses from the RubyGems API.
bundler/lib/dependabot/bundler · high confidence
Common update checker base class with security and cooldown support
The \common/lib/dependabot/update\_checkers\ directory now provides a shared \Base\ class and supporting modules for all ecosystem update checkers. This base class introduces security-aware update logic by accepting \security\_advisories\ and prioritizing the lowest security fix version for vulnerable dependencies. It also adds release cooldown filtering via a new \CooldownCalculation\ module and peer dependency conflict detection through \PeerDependencyConflict\. Additionally, \VersionFilters\ and \VulnerabilityAudit\ structures are included to handle vulnerability filtering and detailed audit reporting.
_common/lib/dependabot/update\checkers · high confidence
Composer ecosystem rewritten with strict typing and Composer v2-only support
The Composer ecosystem implementation has been completely rewritten to enforce Sorbet strict typing across all core components (FileFetcher, FileParser, FileUpdater, UpdateChecker, and document parsers) and to drop support for Composer v1, defaulting to Composer v2. This change introduces a new Composer-specific error handler for better diagnostic messages, adds PHP language version tracking, and updates the metadata finder to use the Packagist v2 API.
composer/lib/dependabot/composer · high confidence
Composer package metadata now includes release dates
The Composer package details fetcher has been refactored to extract and expose release timestamps for package versions. This change introduces new internal classes (\PackageDetailsFetcher\ and \RegistryPackage\) that parse registry JSON responses to capture the \released\_at\ time for each version, making this metadata available to users for better version context.
composer/lib/dependabot/composer/package · high confidence
Configured Bazel bundle to use the dependabot-updater Gemfile
A new configuration file has been added to the Bazel bundle directory to explicitly set the BUNDLE\_GEMFILE environment variable. This directs the bundler to use the Gemfile located in the ../dependabot-updater directory, ensuring that the correct Ruby dependencies are resolved for this specific bundle context.
bazel/.bundle · high confidence
Configured Bundler to use a specific Gemfile path
A new configuration file has been added to the conda bundle settings to explicitly point Bundler to the Gemfile located in the ../dependabot-updater directory. This ensures that dependency resolution and installation within this context use the correct set of Ruby gems defined in that specific location.
conda/.bundle · high confidence
Consolidate Docker support into a shared base module
The Docker and Docker Compose package managers now share a common base implementation. A new top-level \docker.rb\ file registers the core Docker classes (file fetcher, parser, updater, metadata finder, requirement, and version) and sets up label and production check registrations. The \docker\_compose.rb\ file now requires this base module and re-registers the shared classes for the \docker\_compose\ namespace, ensuring that both package managers utilize the same underlying logic while maintaining distinct identity and labeling.
docker/lib/dependabot · high confidence
Devcontainers ecosystem now filters recent releases via cooldown
The devcontainers update checker now includes a cooldown mechanism that suppresses newly released versions for a configurable period. The new LatestVersionFinder class integrates with the shared CooldownCalculation logic, filtering out releases that fall within the cooldown window so that only stable, older versions are presented as available updates.
_devcontainers/lib/dependabot/devcontainers/update\checker · high confidence
Ecosystem support upgraded to Erlang 27 and Elixir 1.19.5
The Hex ecosystem now runs on Erlang 27 and Elixir 1.19.5, ensuring compatibility with the latest language features and package manager (Hex 2.3.1). This update is delivered via a new Dockerfile that installs Erlang from the RabbitMQ Launchpad PPA and Elixir from official releases, alongside a build script that provisions the native helpers in the designated helpers directory.
hex · high confidence
Enhanced Python dependency parsing and hash retrieval
The Python helper library now supports parsing dependencies from PEP 621 and PEP 735 (dependency-groups) formats in pyproject.toml, including build-system requirements and optional dependency groups. It also retrieves dependency hashes from private Python registries (not just PyPI) and improves SSL certificate verification error handling to provide clearer feedback when certificate validation fails.
python/helpers · high confidence
Immutable Git credential helper prevents store mutations
A new git credential helper script (git-credential-store-immutable) has been added to the common bin directory. This wrapper allows only the 'get' command to pass through to the standard git credential-store, effectively blocking 'store' and 'erase' operations to prevent accidental or unauthorized modifications to the credential file.
common/bin · high confidence
Improved Cargo lockfile update reliability with precise version fallbacks
The Cargo file updater now includes a robust mechanism to handle dependencies that require lockstep updates (such as the \futures\ family). When a standard \cargo update\ fails to move a package because sibling crates must be updated together, the system automatically retries with the \--precise\ flag to force the exact target version and cascade changes to siblings. This prevents update failures in complex dependency trees while safely ignoring false positives where other consumers already hold the old version. Additionally, the updater now skips redundant update commands if a dependency's previous version has already been resolved by an earlier step in the process.
_cargo/lib/dependabot/cargo/file\updater · high confidence
Improved Gemfile and gemspec dependency declaration detection
The Bundler file parser now uses the Prism AST parser to more accurately detect whether dependencies are declared in Gemfile and gemspec files. New dedicated finders (GemfileDeclarationFinder and GemspecDeclarationFinder) parse these files using Prism to identify gem declarations, allowing the parser to correctly extract requirement strings and handle complex declaration structures. This change improves the accuracy of dependency detection, particularly for cases where a gemspec loads another gemspec or when requirement strings need to be preserved exactly as written in the source files.
_bundler/lib/dependabot/bundler/file\parser · high confidence
Improved reliability of Composer lockfile updates with retry logic and error handling
The Composer lockfile updater now automatically retries on transitory network failures (such as timeouts or 404 errors) and handles missing PHP extension requirements by updating platform constraints and retrying. It also includes specific handling for git dependency authentication errors and tighter regex patterns to correctly identify missing platform requirements, resulting in more successful updates for projects with complex PHP environment dependencies.
_composer/lib/dependabot/composer/file\updater · high confidence
Introduce Bundler v2 native helper implementation
The bundler helpers now include a new v2 implementation that replaces the previous v1 approach. This change introduces a dedicated module for resolving Bundler version constraints via environment variables and a central \functions.rb\ file that exposes native helper methods for parsing Gemfiles and gemspecs, updating lockfiles, performing force updates, resolving dependency sources (including Git and private registries), and detecting conflicting dependencies. The implementation also handles credential configuration for Git sources and private registries, ensures Bundler is not frozen during resolution, and includes specific logic to support Bundler 4 runtime compatibility.
bundler/helpers/v2/lib · high confidence
Introduce Sorbet-typed Dependabot configuration parsing and ignore logic
The repository's Dependabot configuration handling has been refactored to use strict Sorbet typing across the config file parser, file fetcher, ignore conditions, and update configuration. This change ensures that \dependabot.yml\ files are parsed with stronger type guarantees, correctly mapping package ecosystems (such as Bazel, Bun, Conda, Deno, Julia, Nix, OpenTofu, SBT, Swift, and Vcpkg) to internal identifiers. It also formalizes the logic for \ignore\_conditions\, allowing users to specify dependency names, version ranges, and update types (patch, minor, major) that should be excluded from updates, while supporting wildcard matching for dependency names and handling commit message options and excluded paths with precise type safety.
common/lib/dependabot/config · high confidence
Introduce VendorUpdater to flag vendored dependency files
A new VendorUpdater class has been added to correctly handle vendored files by automatically flagging created DependencyFile objects with the 'vendored' attribute. This ensures that grouped updates are processed correctly, as the updater now distinguishes vendored resources from standard artifacts.
_common/lib/dependabot/file\updaters · high confidence
Introduce native Bundler v2 helper with isolated runtime and monkey patches
The bundler helper now uses a dedicated v2 implementation that installs a specific Bundler version (constrained to \~\> 2) in an isolated gem home, ensuring consistent behavior regardless of the system environment. This helper activates Bundler 2 by default, applies necessary monkey patches for Ruby version and metadata handling, and handles JSON-based input/output for function calls. It also includes a trap for HUP signals to handle timeouts gracefully, providing a more robust and isolated execution environment for Bundler operations compared to previous versions.
bundler/helpers/v2 · high confidence
Introduce v2 monkey patches to stabilize dependency resolution
Added a new set of monkey patches in the v2 bundler helper to fix specific dependency resolution failures. The patches prevent crashes when parsing empty checksum metadata from registries, ensure the Ruby version is correctly detected from the .ruby-version file, ignore the Bundler version specified in the Gemfile to avoid conflicts, and convert SSH Git URLs to HTTPS to support authentication-less environments.
_bundler/helpers/v2/monkey\patches · high confidence
Introduces DependencySet to track multiple versions of dependencies
A new \DependencySet\ class has been added to the common file parser base to handle ecosystems where a single dependency name may appear with multiple versions. This component tracks all encountered versions of a dependency and combines them into a unified entry, preserving requirements and subdependency metadata while deduplicating them. It also supports case-insensitive name matching and allows retrieval of all individual versions in insertion order, ensuring that transitive and direct dependencies are correctly merged without losing version history.
_common/lib/dependabot/file\parsers/base · high confidence
New lockfile and requirement update logic for Bundler
The Bundler file updater now uses a dedicated \LockfileUpdater\ class to regenerate lockfiles via a native Bundler subprocess, ensuring accurate dependency resolution. It also introduces a \RequirementReplacer\ that leverages the Prism parser to precisely rewrite version requirements in Gemfiles and gemspecs, preserving code formatting and comments during updates.
_bundler/lib/dependabot/bundler/file\updater · high confidence
New native NuGet updater with .NET 10 support and improved SDK handling
The NuGet ecosystem now uses a new native C\# updater tool (\NuGetUpdater.Cli\) instead of the previous Ruby implementation. This change introduces support for .NET 10 (targeting \net10.0\) alongside .NET 8 and 9, and updates the Docker image to install SDK versions 8.0.424, 9.0.317, and 10.0.400. The updater now handles SDK installation dynamically based on \global.json\ files, including robust parsing of channel versions (e.g., \9.0.x\) and whitespace handling. It also improves version comparison for pre-release and build identifiers, correctly preserving build metadata in version strings and handling NuGet-specific range syntax (e.g., \\[1.0.0, 2.0.0)\). Additionally, the updater ensures proper file casing for \NuGet.Config\ and installs required targeting packs automatically.
nuget · high confidence
Refactor Bundler update checker to use native subprocesses and Sorbet typing
The Bundler update checker logic has been refactored to delegate heavy resolution and update tasks to native Bundler subprocesses, introducing new classes like ConflictingDependencyResolver, CooldownOptionsBuilder, FilePreparer, ForceUpdater, and VersionResolver. This shift improves reliability by leveraging Bundler's own resolution engine and adds Sorbet strict/strong typing across the module. Users benefit from more robust handling of dependency conflicts, source cooldowns, and version resolution, with better error reporting for private registries and git sources.
_bundler/lib/dependabot/bundler/update\checker · high confidence
Refactor Composer version resolution into dedicated LatestVersionFinder and VersionResolver classes
The Composer update checker now uses a new \LatestVersionFinder\ class to handle fetching and filtering available package versions (including security fixes and cooldowns) and a new \VersionResolver\ class to manage the actual resolution process via Composer subprocesses. This change introduces stricter Sorbet typing (\\# typed: strong\/\strict\), adds an error handler for Composer-specific failures, and implements retry logic for transitory network errors, improving reliability and maintainability of the version resolution logic.
_composer/lib/dependabot/composer/update\checker · high confidence
Refactor Hex helper scripts to use structured JSON output and stderr logging
The Hex helper scripts in \hex/helpers\ have been rewritten to improve reliability and integration. Logging is now directed to stderr instead of stdout, ensuring that structured output remains parseable. The scripts (\parse\_deps.exs\, \check\_update.exs\, \do\_update.exs\) now return results via Base64-encoded binary serialization, which is decoded and wrapped in JSON by the new \run.exs\ orchestrator. This change introduces structured error handling for dependency resolution, including specific messages for invalid requirements and timeouts, and supports self-hosted Hex repositories by allowing credential configuration for custom repos and organizations.
hex/helpers · high confidence
Refactor latest version detection into a dedicated DependencySource class
The logic for determining a dependency's source type and fetching its available versions has been extracted from the main LatestVersionFinder into a new DependencySource class. This change introduces explicit handling for different source types (RubyGems, private registries, and Git) and adds support for requesting gzip-compressed responses from the RubyGems API to improve efficiency. It also ensures that dependencies sourced from Git repositories return an empty list of registry versions, while private registry versions are now fetched via a native Bundler subprocess helper.
_bundler/lib/dependabot/bundler/update\_checker/latest\_version\finder · high confidence
Refactored Cargo update checking into dedicated FilePreparer, LatestVersionFinder, and VersionResolver classes
The Cargo update-checking logic has been restructured into three new, strictly-typed classes to improve maintainability and error handling. The new \FilePreparer\ sanitizes dependency manifests for update checks by replacing version constraints with temporary requirements, handling workspace and target-specific dependencies, and managing Git pin replacements. The \LatestVersionFinder\ now explicitly supports finding the lowest security fix version and includes logic to handle pre-release requirements and cooldowns. The \VersionResolver\ orchestrates the resolution process, running \cargo update\ in a temporary directory and parsing the resulting lockfile to identify the latest resolvable version, with improved handling for Git dependencies and package identity matching.
_cargo/lib/dependabot/cargo/update\checker · high confidence
Refactored PR message and title generation into dedicated builder classes
The logic for composing Pull Request content has been extracted from the main MessageBuilder into two new, dedicated classes: MetadataPresenter and TitleBuilder. MetadataPresenter now handles the assembly of all metadata sections (vulnerabilities, releases, changelogs, commits, etc.) and applies consistent sanitization for links and mentions across all platforms. TitleBuilder manages PR title composition, supporting both the full updater path with auto-detected commit styles and the API path using explicit commit message options, ensuring consistent formatting and prefixing. This change improves code organization and maintainability without altering the user-facing output.
_common/lib/dependabot/pull\_request\_creator/message\builder · high confidence
Repository reorganization and development environment updates
The repository has been reorganized into a modular structure with dedicated gems for each ecosystem, and the development environment has been updated to use Ruby 4.0.5 and Ubuntu 24.04. The project now uses a new .rubocop.yml configuration with Sorbet type checking enabled, and includes updated .gitignore, .dockerignore, and .editorconfig files. The CHANGELOG has been consolidated into an archive file, and the project now uses GitHub Releases instead of a traditional changelog. Development tools include updated Dockerfiles for both development and core updater images, with improved support for VS Code Remote Development and debugging.
(repo-wide) · high confidence
Safer and stricter parsing of Bundler dependency files
The Bundler file fetcher now uses the Prism parser instead of the previous Parser gem to analyze Gemfiles and related files. This change improves security by removing the use of \eval\ for resolving included paths, replacing it with static AST analysis that only supports uninterpolated string arguments for \eval\_gemfile\, \gemspec\, and \path\ dependencies. Additionally, these finder components have been strictly typed with Sorbet to ensure more robust handling of file paths and dependency declarations.
_bundler/lib/dependabot/bundler/file\fetcher · high confidence
Standardize Bundler configuration for Dependabot updater
Added .bundle/config files to the bundler, cargo, common, composer, and docker directories to explicitly point BUNDLE\_GEMFILE to the ../dependabot-updater/Gemfile. This ensures that Bundler operations in these subdirectories consistently use the shared dependency definitions from the Dependabot updater project.
(repo-wide) · high confidence
Support building path dependencies from lockfile data
The Composer file fetcher can now construct path dependencies by extracting their manifest content directly from the lockfile. Previously, path dependencies that were not directly fetchable might have failed; this change introduces a PathDependencyBuilder that parses the lockfile to generate the necessary dependency file content, ensuring path-based packages are handled correctly during the fetch phase.
_composer/lib/dependabot/composer/file\fetcher · high confidence
Updater component restructured into typed command classes with dependency grouping support
The updater directory has been reorganized to use Sorbet-typed command classes (BaseCommand, UpdateFilesCommand, UpdateGraphCommand) that wrap the update logic, replacing the previous monolithic entry points. This change introduces a DependencyGroupEngine to manage user-defined dependency groups, allowing dependencies to be assigned to groups based on rules and updated together. It also adds a DependencyChange model to encapsulate update results, including attribution metadata for observability, and integrates with the Service API for error reporting and telemetry. The entry points now support both file-based and graph-based updates, with improved error handling and logging.
updater · high confidence
Workspace Git operations now use explicit store\_change and prevent user message leakage
The workspace Git implementation now requires an explicit call to \store\_change\ to persist modifications, rather than storing them by default, and ensures that user commit messages are not logged during debugging. Additionally, the \git add\ command has been fixed to handle paths with spaces correctly by using array arguments, and the committer identity is now explicitly configured to avoid warnings.
common/lib/dependabot/workspace · high confidence
Test coverage
1 commit adding/updating tests in cargo/spec/fixtures/git; 1 commit adding/updating tests in composer/spec/fixtures/git; Add PGP key fixtures and configure test infrastructure; Add shared WebMock adapter for Gem::Net::HTTP in tests; Added Azure API response fixtures for testing; Added Bun CI test script; Added CI test script for Bazel ecosystem; Added CI test script for devcontainers using turbo\_tests2; Added CI test scripts for cargo, common, and docker ecosystems; Added Cargo lockfile fixtures for testing edge cases; Added Deno test infrastructure scripts; Added Docker fixture files for testing various image reference formats; Added ECR authentication test fixtures; Added Ruby gemspec and RubyGems API response fixtures; Added Ruby gemspec and index fixtures for bundler tests; Added bundler2 project fixtures for testing; Added changelog fixture files for testing; Added comprehensive test coverage for the Composer ecosystem; Added conda test infrastructure and migrated to turbo\_tests2; Added empty main.rs fixture for version conflict tests; Added npm registry response fixtures for Bun ecosystem tests; Added spec helper for Cargo tests; Added test coverage for Azure, GitHub, and GitLab pull request updaters; Added test coverage for Bazel ecosystem support; Added test coverage for Bundler file fetcher finders; Added test coverage for Bundler v2 helper functions; Added test coverage for Cargo update checker components; Added test coverage for core Dependabot common components; Added test coverage for package metadata parsing and cooldown logic; Added test coverage for provider client implementations; Added test coverage for the Conda ecosystem implementation; Added test coverage for the devcontainers ecosystem; Added test coverage for the dummy package manager implementation; Added test coverage for update checker core logic and security filtering; Added test fixture for Poetry relative path defect; Added test fixture for Rust project with no configuration; Added test fixture for git tag details; Added test fixture for git-upload-pack protocol; Added test fixtures for Bundler Compact Index v2 and Dependabot Common metadata; Added test fixtures for CodeCommit client; Added test fixtures for Julia workspace sub-packages; Added test fixtures for command execution scenarios; Added test fixtures for docker-compose parser edge cases; Added test fixtures for local path module resolution; Added test fixtures for lockstep and duplicate source scenarios; Added test fixtures for nested Terraform local modules with provider version constraints; Added test fixtures for vendor gem handling scenarios; Added test helper scripts for subprocess error simulation; Added test scaffolding for Julia package support; Added test suite for Bun ecosystem support; Added test suite for Bundler v2 native helpers; Added test suite for Dependabot file fetcher base class; Added test suite for the bin/dry-run script; Added tests for Bundler PackageDetailsFetcher error handling; Added tests for Bundler file parser components; Added tests for Cargo lockfile and manifest file updaters; Added tests for Composer package metadata fetching and parsing; Added tests for Composer path dependency builder; Added tests for Composer updater class registration and version consistency; Added tests for Dependabot config parsing and ignore conditions; Added tests for DependencySet behavior; Added tests for DependencySource credential handling; Added tests for Docker Compose file fetching, parsing, and updating; Added tests for Docker and Docker Compose class registration; Added tests for Docker credentials finder logic; Added tests for Git commit checker source details parsing; Added tests for PR message builder components; Added tests for autoloading registration in Bundler and Cargo adapters; Added tests for base metadata finders; Added tests for branch naming strategies; Added tests for the base file parser and shared parser examples; Added tests for the common metadata finder base class and shared examples; Added tests for the workspace Git integration; Added unit tests for file updater components; Automated CI test execution script for Bundler; Enable Sorbet type checking for Rust toolchain specs; Expanded test coverage for Cargo ecosystem file handling; Expanded test coverage for Docker ecosystem update logic; Expanded test fixtures for Cargo manifest parsing; Initial test coverage for the dotnet\_sdk ecosystem; Initial test infrastructure for Composer integration; Introduce CI test script using turbo\_tests2; New 'silent' ecosystem for integration testing; New test infrastructure for Bundler specs; Removed Ruby file parser spec and RSpec its helper; Updated RubyGems API response fixtures for testing.
Dependencies
2480 commits updating dependencies (2137 manifests)
A dependency / build maintenance change in (dependencies) — 2480 commits (175 fixs), 2137 files: “Bump prettier from 2.8.0 to 2.8.1 in /npm\_and\_yarn/helpers”; “Bump the dev-dependencies group in /composer/helpers/v2 with 2 updates”; “Adds exception handling for override failure errors (\#10290)”; and 2281 more (refs \#10290, \#13265, \#10494, \#15901, \#6917, …).
(dependencies) · high confidence · unverified
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 44 → 36 (-8.8)
- Rubric changed (rubric-2026.10.5 → rubric-2026.11.4) — scores are not directly comparable.
Lenses
- Code Health 51 → 40 (-10.9)
- Architecture 70 → 49 (-21.3)
- Maturity 72 → 80 (+7.3)
- Readiness 61 → 56 (-4.8)
- Security 29 → 21 (-8.3)
- Performance 60 → 60 (+0.0)
Resolved (66)
- Coverage not measured — .NET suite
- Critical CVE: [GHSA redacted] (npm_and_yarn/helpers/package-lock.json)
- DetailedPullRequestBodyGenerator.GeneratePullRequestBodyTextAsync (cognitive 63) (nuget/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Run/PullRequestBodyGenerator/DetailedPullRequestBodyGenerator.cs)
- DetailedPullRequestBodyGenerator.GeneratePullRequestBodyTextAsync (cyclomatic 22) (nuget/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Run/PullRequestBodyGenerator/DetailedPullRequestBodyGenerator.cs)
- Documentation: no map of the repository's parts (README.md)
- Duplicated block (10 lines × 2) (pre_commit/lib/dependabot/pre_commit/additional_dependency_checkers/go.rb)
- Duplicated block (11 lines × 2) (nuget/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Run/UpdateHandlers/RefreshSecurityUpdatePullRequestHandler.cs)
- Duplicated block (13 lines × 2) (python/lib/dependabot/python/file_parser.rb)
- Duplicated block (15 lines × 2) (pre_commit/lib/dependabot/pre_commit/additional_dependency_checkers/dart.rb)
- Duplicated block (16 lines × 2) (github_actions/lib/dependabot/github_actions/package/package_details_fetcher.rb)
- Duplicated block (18 lines × 2) (bun/lib/dependabot/bun/file_fetcher/path_dependency_builder.rb)
- Duplicated block (18 lines × 2) (composer/lib/dependabot/composer/file_updater/lockfile_updater.rb)
- Duplicated block (21 lines × 2) (bun/lib/dependabot/bun/file_fetcher/path_dependency_builder.rb)
- Duplicated block (24 lines × 2) (bun/lib/dependabot/bun/file_fetcher/path_dependency_builder.rb)
- Duplicated block (27–28 lines × 2) (updater/lib/dependabot/update_files_command.rb)
- Duplicated block (36–37 lines × 2) (bun/lib/dependabot/bun/file_parser.rb)
- Duplicated block (6 lines × 2) (bun/lib/dependabot/bun/file_fetcher/path_dependency_builder.rb)
- Duplicated block (6 lines × 2) (bun/lib/dependabot/bun/file_fetcher/path_dependency_builder.rb)
- Duplicated block (6 lines × 2) (bun/lib/dependabot/bun/file_parser.rb)
- Duplicated block (6 lines × 2) (docker/lib/dependabot/docker/version.rb)
- …and 46 more
New (460)
- Critical CVE: [GHSA redacted] (npm_and_yarn/helpers/package-lock.json)
- Critical CVE: [GHSA redacted] (npm_and_yarn/helpers/package-lock.json)
- Critical CVE: [GHSA redacted] (npm_and_yarn/helpers/package-lock.json)
- DetailedPullRequestBodyGenerator.GenerateUpdateSectionAsync (cognitive 47) (nuget/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Run/PullRequestBodyGenerator/DetailedPullRequestBodyGenerator.cs)
- DetailedPullRequestBodyGenerator.GenerateUpdateSectionAsync (cyclomatic 20) (nuget/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Run/PullRequestBodyGenerator/DetailedPullRequestBodyGenerator.cs)
- Duplicated block (10 lines × 2) (nuget/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Run/UpdateHandlers/RefreshSecurityUpdatePullRequestHandler.cs)
- Duplicated block (10 lines × 2) (updater/lib/dependabot/update_files_command.rb)
- Duplicated block (11 lines × 2) (updater/lib/dependabot/file_fetcher_command.rb)
- Duplicated block (13 lines × 2) (nuget/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Run/UpdateHandlers/RefreshSecurityUpdatePullRequestHandler.cs)
- Duplicated block (13 lines × 2) (python/lib/dependabot/python/file_parser.rb)
- Duplicated block (19 lines × 2) (bun/lib/dependabot/bun/file_parser.rb)
- Duplicated block (21 lines × 2) (composer/lib/dependabot/composer/file_updater/lockfile_updater.rb)
- Duplicated block (22 lines × 2) (github_actions/lib/dependabot/github_actions/package/package_details_fetcher.rb)
- Duplicated block (24 lines × 2) (nuget/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Run/UpdateHandlers/RefreshSecurityUpdatePullRequestHandler.cs)
- Duplicated block (27 lines × 2) (nuget/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Run/UpdateHandlers/RefreshSecurityUpdatePullRequestHandler.cs)
- Duplicated block (7 lines × 2) (pre_commit/lib/dependabot/pre_commit/package/package_details_fetcher.rb)
- Duplicated block (9 lines × 2) (updater/lib/dependabot/update_files_command.rb)
- Duplicated block (9–10 lines × 3) (nuget/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Run/UpdateHandlers/RefreshGroupUpdatePullRequestHandler.cs)
- Edited copies of one member (3 members, 1+ corresponding lines) (apm/lib/dependabot/apm/update_checker.rb)
- Edited copies of one member (3 members, 1+ corresponding lines) (composer/lib/dependabot/composer/lockfile_document.rb)
- …and 440 more
Changes since last survey
- 94 commits — 87 feature/other, 7 fixes
By area
- updater/lib — 7 commits
- common/lib — 6 commits
- nuget/helpers — 6 commits
- python/lib — 6 commits
- python/spec — 4 commits
- (root) — 3 commits
- github_actions/lib — 3 commits
- gradle/spec — 3 commits
- npm_and_yarn/lib — 3 commits
- npm_and_yarn/spec — 3 commits
- bundler/helpers — 2 commits
- bundler/spec — 2 commits
- docker/lib — 2 commits
- go_modules/spec — 2 commits
- helm/lib — 2 commits
- julia/lib — 2 commits
- maven/spec — 2 commits
- nix/spec — 2 commits
- updater/spec — 2 commits
- .github/labeler.yml — 1 commit
Notable commits
- fix: Fix cooldown ending early for git tags (#16889)
- fix: Fix Composer implicit PHP requirement retries (#16747)
- fix: Fix Gradle security updates for lockfile-only transitive dependencies (#16880)
- fix: Fix NuGet compatibility checks for versioned platform targets (#16869)
- fix: Fix Poetry Python constraints with the OR (||) operator (#16833)
- fix: Fix gradle incorrect update for same group id and version (#16829)
- fix: Revert Excon EOF error fingerprint updates (#16818)
- change: Add additional context for no files changed error for cargo, go_modules, maven, gradle, sbt (#16904)
- change: Add backtrace to security update failed errors (#16814)
- change: Add error-context to unknown errors from common error producers (#16844)
- change: Add missing PR labeler entries for julia, conda, bazel, nix, sbt, pre… (#16752)
- change: Add support for Python 3.15 (#16525)
- change: Align Python marker parsing between FileParser and UpdateChecker to avoid dropping requirements (#15875)
- change: Align uv marker parsing with python and assume non-python markers are satisfied (#16864)
- change: Bump gh-actions-lock to v0.4.1 (#16799)
- change: Bundler: skip untracked top-level gems when a forced update changes them (#16927)
- change: Don't report removed dependencies as failed group security updates (#16708)
- change: Don't report semver-rejected dependencies as failed group security updates (#16728)
- change: Don't treat Maven registry rate limits and server errors as no versions (#16688)
- change: Enable Sorbet checking for APM specs (#16710)
- …and 74 more
Architecture
- Unchanged — 2 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
dependabot/dependabot-core 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 14 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 13987a86518585c1b2fd84124ab23391dd5a318b — the exact code this score is about.
- Scored under rubric-2026.11.4 — 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.65+preprod-36d4cd83012f.