Skip to content

Managers

A manager finds dependencies in one kind of file and knows how to edit them. Every manager is on by default; managers in your config replaces the list, and files replaces one manager’s file patterns.

Edits are surgical. Each dependency is extracted with the exact byte range of its version, and an update rewrites those bytes and nothing else, keeping your quoting, comments and formatting.

Manager Files Lockfile the Count regenerates
npm package.json, pnpm-workspace.yaml and .yarnrc.yml catalogs, .nvmrc, .node-version, .npmrc registries package-lock.json, npm-shrinkwrap.json, aube-lock.yaml, pnpm-lock.yaml, yarn.lock, bun.lock
bun package.json when npm is off bun.lock
github-actions .github/workflows/*.yml, .forgejo/workflows/*.yml, .gitea/workflows/*.yml (each also .yaml), action.yml, action.yaml
mise mise.toml, .mise.toml, .tool-versions mise.lock
cargo Cargo.toml, rust-toolchain, rust-toolchain.toml Cargo.lock
go go.mod go.sum
dockerfile Dockerfile, Dockerfile.*, *.Dockerfile, *.dockerfile
compose compose*.yml, docker-compose*.yml (each also .yaml)
kubernetes Kubernetes manifests (*.yaml, *.yml)
kustomize kustomization.yaml, kustomization.yml, Kustomization
flux Flux HelmRepository, HelmRelease, OCIRepository
helm-values values*.yaml, *values.yaml (each also .yml)
helm Chart.yaml not yet: Chart.lock holds the update
terraform *.tf, .terraform-version .terraform.lock.hcl
pyproject pyproject.toml, .python-version, uv.toml indexes uv.lock, poetry.lock
pre-commit .pre-commit-config.yaml
devcontainer devcontainer.json, .devcontainer.json
woodpecker .woodpecker.yml, .woodpecker.yaml, .woodpecker/*.yml and *.yaml
copier .copier-answers.yml, .copier-answers.yaml, .copier-answers.*.yml and *.yaml none: newer template versions are reported, not applied
maven pom.xml
gradle *.gradle, *.gradle.kts, gradle.properties, gradle/*.versions.toml, the wrapper the wrapper checksum; gradle.lockfile holds the update
nuget *.csproj, *.fsproj, *.vbproj, Directory.Packages.props, Directory.Build.props, global.json, .config/dotnet-tools.json packages.lock.json
bundler Gemfile, .ruby-version Gemfile.lock
composer composer.json composer.lock
gitlabci .gitlab-ci.yml, *.gitlab-ci.yml (and .yaml)
gitlabci-include .gitlab-ci.yml, *.gitlab-ci.yml (and .yaml)
nix flake.lock beside a flake.nix flake.lock
apm apm.yml, apm.yaml apm.lock.yaml
regex whatever your extractors select

Lockfiles provide the current version where they exist. Their transitive entries only become dependencies of their own, of kind transitive, when they have a known vulnerability. A file that does not parse at all, such as an ERB-templated YAML file, is skipped with a warning and the rest of the repository carries on.

Declarations a manager cannot read as versions are skipped: each is listed with its line and reason in the run summary and under skipped in the JSON report. Unlike a warning, a skip doesn’t hold back branch cleanup or auto-merge.

npm covers dependencies, devDependencies, peers, optional dependencies, aliases (npm:pkg@^1), nested overrides, resolutions and packageManager. workspace:, file:, link:, catalog:, portal:, patch: and the other local protocols name no registry version and are left alone. Catalogs are dependencies where they are declared: catalog and named catalogs in pnpm-workspace.yaml, .yarnrc.yml for Yarn 4, and the root package.json for Bun. .nvmrc and .node-version pin Node; aliases such as lts/* are not versions. .npmrc and .yarnrc.yml name each package’s registry.

When both npm and bun are enabled, npm owns package.json so nothing is updated twice. Binary bun.lockb is not supported; switch to text bun.lock.

Workflow steps, reusable workflows, job containers, services and composite action steps. run: text, expressions and local ./ actions are ignored. Actions and images are pinned to digests by default, keeping the version in a comment. A SHA pin with a version comment (@8e5e7e5... # v4.2.2) upgrades both; one without a comment cannot safely pick a replacement tag, so it stays put with a warning. Branch refs keep the branch and only refresh the digest. Setup actions’ version inputs (node-version, go-version, bun-version, golangci-lint and goreleaser versions) are tools in their own right. Hosted runner labels in runs-on, such as ubuntu-24.04, upgrade within their OS and architecture family; ubuntu-latest floats and is left alone. Flow-style YAML and YAML aliases at a version location are not editable yet and report an error.

A repository keeping .github/workflows/actions.lock (made by gh actions-lock) gets it regenerated in the same commit as an update to an action in a workflow the lockfile lists; if it cannot be regenerated, the update is held with the reason rather than opening a PR whose lock would be stale. Lockfile maintenance also relocks the refs that moved upstream in the workflows it lists. The Count never adds a workflow or an action to the lockfile, and repositories without the file — and workflows it does not list — are unchanged. In a listed workflow he adds no new step-level SHA pin, since the lockfile is the pin; an existing pin still upgrades, and reusable workflows still pin. See the lockfile run for how the tool is invoked and the departure for why pinning differs there.

Workflows in .forgejo/workflows/ and .gitea/workflows/ at the repository root are read the same way, by the same github-actions manager, and pinned and updated the same way. An action can be named by URL there, such as https://code.forgejo.org/actions/setup-forgejo@v3. A URL on github.com is looked up as GitHub tags; a URL on a Gitea or Forgejo host is looked up as forge-tags on that host, and the Count keeps the URL when he rewrites the ref. Hosts are recognised by name: codeberg.org, gitea.com, and hosts with a gitea or forgejo label such as code.forgejo.org or git.forgejo.example.com. Actions on other hosts are skipped.

A bare owner/repo ref is resolved by the runner against the instance’s default action host, which only the instance’s app.ini knows. The Count uses each project’s documented default:

File Bare owner/repo looked up on
.github/workflows/, .gitea/workflows/, action.yml GitHub, Gitea’s default (DEFAULT_ACTIONS_URL = github)
.forgejo/workflows/, .forgejo/**/action.yml data.forgejo.org, Forgejo’s default

If your instance changes DEFAULT_ACTIONS_URL, write the actions it should not resolve this way as URLs. That is what Forgejo recommends anyway. Forge digests come from the host’s tag list, so only tag refs are pinned there: a branch ref such as @main on a forge is left alone. Runner labels in .forgejo/ and .gitea/ workflows name the instance’s own runners, so they are not updated.

Strings, arrays, version tables and .tool-versions. A task’s own tools are read too: under [tasks.<name>] in mise.toml and .mise.toml, and in a TOML task file that one of those configs includes with task_config.includes, by file, glob (tasks/*.toml) or directory (its TOML files at any depth). In a task file every top-level table is a task, so a table named tools is a task, not the tool section. The Count finds a task file through the config that includes it, but only reads files in the mise entry of files. That entry replaces the defaults, so keep them when you add the task file:

files {
new FileSet {
manager = "mise"
paths {
"**/mise.toml"
"**/.mise.toml"
"**/.tool-versions"
"tasks.toml"
}
}
}

The Count asks mise itself for each tool’s versions (mise ls-remote --json), so a tool is found wherever mise finds it: a short registry name such as jq, or an identifier for any backend that reads release metadata (aqua, github, gitlab, forgejo, packslip, npm, pypi, cargo, go, gem, dotnet, conda, spm and core). That includes every form of packslip source: packslip:owner/repo, packslip:github.com/owner/repo, a tool inside a monorepo (packslip:github.com/owner/repo/tools/name) and a tool on a publisher’s domain. An existing mise.lock is regenerated with the update. mise runs in a sandbox, with the Count’s own pinned mise and none of your configuration.

A tool’s options, in its table (rust = { version = "1.100.0", profile = "minimal" }) or in brackets on its name ("github:org/tool[bin=tool]"), go to mise with the lookup, so it lists versions the way it installs them, api_url and version_list_url included. Some tools are refused for safety (plugin backends, Git-ref installs); see mise lookups.

The options stay out of the tool’s branch name: "github:org/tool[bin=tool]" updates on patchula/github-org-tool-1.x. When the same tool appears with different options, each branch name keeps its options so the branches stay apart.

http: and s3: tools without version_list_url (or version_prefix for s3, also per platform under platforms) are skipped with a reason, not looked up: mise lists their versions only from those options, so there is nothing to ask. They are not counted as lookup failures.

Cargo reads workspace, development, build and target tables and renamed crates, and resolves from the nearest Cargo.lock. A member’s workspace = true points at the root declaration, which is where the edit goes. rust-toolchain(.toml) pins Rust.

A path or git dependency is not looked up on crates.io. When it also names a version (the form a workspace crate uses to be publishable), it is skipped with a reason; the Count does not keep that version in step with the crate it points at. Without a version it is ignored. A dependency from an alternate registry is skipped with the registry’s name.

Go reads require blocks and single directives, plus the go directive (kind go-directive, the minimum language version) and toolchain. Indirect requirements are maintained too. A module a replace directive names, in go.mod, a go.work in its folder or above, or any module that workspace uses, is listed as skipped, and so is a module the workspace itself holds: its requirement is not what the build uses, and moving it past a version-specific replacement would take the build off the replacement. A replace directive, go.work or used module the Count cannot read fails every lookup of that module.

Terraform reads providers, registry modules and the provider lock with a real HCL parser; .terraform-version pins Terraform itself.

woodpecker reads the images of steps, services and the clone step, under steps: or the older pipeline: key, written as a map or a list. Only the root .woodpecker.yml or .woodpecker.yaml and files directly inside .woodpecker/ are workflows. Images, plugins included, are pinned to digests by default like any other container image. An image defined once under a YAML anchor and aliased by several steps is one dependency, edited at the anchor; one merged into a step with <<: *anchor is read too.

An image built from a variable, such as golang:${GO_VERSION} from the workflow’s matrix or ${REGISTRY}/tool:1 from the environment, is only known when the workflow runs, so it is skipped.

copier reads the template a project was generated from: _src_path and the tag in _commit of each answers file. Templates on GitHub (gh: included) are looked up as github-tags, and templates on GitLab (gl: included), Gitea and Forgejo as forge-tags, compared as pep440 versions. SSH URLs are looked up over the same host’s API. A template on any other host, a local template, or a _commit that is not a release tag (such as v1.4.0-5-g1a2b3c4) is skipped.

A newer tag is reported, never proposed: the run summary, the JSON report under notices, the dashboard and the TUI show “template gh:acme/template: v1.4.0 → v1.6.0 available”, with a compare link where the host has one. The release-age wait and rules apply as usual, and the kind is template. The Count never opens a PR for it or edits _commit; see the departure.

patchula apply --copier and the TUI’s Templates tab can run your own copier update on request; see applying updates.

apm reads the Git packages listed under dependencies.apm and devDependencies.apm in an APM manifest, written [host/]owner/repo[/path]#ref. Packages without a host are on GitHub and are looked up as GitHub tags; packages on GitLab, Codeberg, Gitea and Forgejo hosts are looked up as forge tags. A virtual package’s path is kept, and the repository is the first two path segments.

These packages are agent instructions, so the Count treats them like actions. By default a tag is pinned to its commit, with the tag kept in a comment (owner/repo#<sha> # v1.2.0), and a commit pin with a tag comment is kept current the same way. The release-age wait applies, and nothing merges by default. A new tag is written exactly as upstream tagged it, so v2.0 stays v2.0 and never becomes 2.0.0. Set defaults { actionDigests = false }, or a rule with digest = false for managers { "apm" }, to keep plain tags.

These entries are skipped:

  • an entry with no #ref, which the lockfile pins;
  • a branch, or a tag that is not a version, such as #main;
  • a short commit, or a full commit with no tag comment;
  • an entry in a flow-style list (apm: [owner/repo#v1]), where a tag comment would swallow the rest of the list;
  • a full URL (https://, ssh://, git@), an object entry (git:), a registry or marketplace entry;
  • a host with no tag source the Count can read, such as Bitbucket or Azure DevOps, or a host with a port.

Local paths are not dependencies. MCP and LSP servers are not read.

When apm.lock.yaml sits beside apm.yml, the Count refreshes it with apm lock; see lockfiles.

Dockerfiles support global ARG substitution, continuations, --platform and stage aliases; scratch and references to earlier stages are skipped. Compose reads each service’s image. Kubernetes reads workload images, Kustomize its images and helmCharts transforms, Flux its repositories and releases, and Helm values files their repository/tag/digest maps. ConfigMaps, Secrets and annotations are not dependencies. Templated images need concrete values; Helm templates are not rendered. Image updates keep the tag’s variant.

pyproject reads PEP 621 dependencies and optional dependencies, PEP 735 dependency groups, uv’s dev, constraint and override dependencies, and Poetry’s dependencies and groups. Edits touch only the version specifier. URL requirements, unversioned names and Poetry git/path sources are skipped. Names are PEP 503 normalised and resolved from uv.lock or poetry.lock; .python-version pins CPython. Neither uv nor Poetry may build a package to lock it, so an update whose lock would need a build (a workspace package with dynamic metadata, or a dependency with only a source distribution) is skipped with the reason; see lockfiles.

pip requirements files are not maintained: each is listed as skipped, with the reason. pip takes each package from whatever index the file’s options, the files it includes and the environment name, and the Count cannot settle that for certain from the repository; a guess could propose someone else’s package of the same name. Move the project to uv (uv init --bare, then uv add -r requirements.txt) to have it maintained. See pip requirements files.

gitlabci reads the image and services of every job, default and hidden .template jobs, as a string or as a name: mapping. Images are pinned to digests by default, like images everywhere else, and GitLab’s own registry, registry.gitlab.com, is read with the anonymous tokens gitlab.com issues. It also updates CI/CD component references (include: - component: gitlab.com/components/sast/sast@3.4.0) from the component project’s tags. ~latest and commit SHAs are left alone.

gitlabci-include updates the ref of include: project: entries from that project’s tags. Refs and component versions are written as the tag is named, since GitLab loads them by exact name. Entries without a ref, branch names and commit SHAs are left alone, and so are local, remote and template includes. A ref or component reference shared through a YAML anchor is skipped, since one tag may not exist in every project that uses it; an anchored image is edited once, at the anchor.

Project includes resolve on gitlab.host, gitlab.com by default, and so does $CI_SERVER_FQDN (or $CI_SERVER_HOST) at the start of a component reference. A self-hosted instance works when it has a gitlab label in its host name, such as gitlab.example.com, whether it is named in the component reference or in config:

gitlab { host = "gitlab.example.com" }

Other GitLab CI variables are not expanded. An image such as $CI_REGISTRY_IMAGE:latest or ${CI_DEPENDENCY_PROXY_GROUP_IMAGE_PREFIX}/node:22 is skipped.

helm reads Chart.yaml dependencies from HTTPS and oci:// repositories. An oci:// chart is an image to the Count: its registry digest follows imageDigests, like a container image’s, whether it is declared in Chart.yaml, Kustomize helmCharts or a Flux source. pre-commit updates each hook repository’s rev on GitHub, GitLab, Codeberg and Gitea/Forgejo hosts, skipping local and meta hooks and bare commit pins. A rev is written as the tag is named (v1.0 becomes v1.1, not v1.1.0), since pre-commit checks it out by that name. pre-commit accepts any git ref as a rev, so a branch name or another ref that names no version is left alone: there is no version to look up, and no error. devcontainer reads the image and OCI features, whose version lives in the feature key (ghcr.io/devcontainers/features/node:1).

Maven reads parent, dependencies, dependencyManagement, build plugins, pluginManagement and extensions. A ${property} version is edited where the property is defined.

Gradle reads version catalogs, literal coordinates, group:/name:/version: notation and id "…" version "…" plugins in every Gradle script. It resolves versions kept in ext blocks, def/val locals, extra[...], map literals such as versions += [jackson: "2.15.0"], and gradle.properties.

Gradle skips anything under src/ except src/main/, since test resources hold fixtures; a name defined twice; computed values; the project’s own version; and packages reached through several variables, which are deliberate parallel versions such as Kafka’s compatibility pins. A script with a comment, string or template that never ends is skipped with a warning, since Gradle could not compile it either; its comments are found by the same lexer that reads its repositories. The wrapper’s distributionUrl upgrades, and a recorded distributionSha256Sum is replaced with Gradle’s published checksum.

Versions keep their release variant: Guava’s 33.4.8-android never becomes 33.7.2-jre.

nuget reads PackageReference, PackageVersion and GlobalPackageReference items, local tools and the SDK in global.json (feature-band releases only). $(Property) and floating * versions are skipped. Where each package comes from is in package registries. Lockfiles are restored with dotnet restore --force-evaluate.

bundler reads gem "name", "requirement" lines and the ruby directive, resolving from Gemfile.lock, plus .ruby-version. Gems from git, a path or a forge (git:, path:, github: and the like, or a GIT or PATH section of the lock) are listed as skipped; where each gem comes from is in package registries. Gems with two requirement strings are skipped too, and so are gems with no requirement at all: any version satisfies them, so only lockfile maintenance moves them. Evaluating a Gemfile runs Ruby, so Bundler never sees the repository’s: bundle lock runs on a Gemfile the Count renders from its reading, outside the checkout. An update whose Gemfile needs a form the Count does not render (a gemspec, a gem from git, a path or a forge, or any line it does not read), or whose Gemfile.lock has a GIT, PATH or PLUGIN SOURCE section, is skipped with the reason; see lockfiles.

composer reads require and require-dev, skipping platform packages (php, ext-*, lib-*), dev- branches and *. Packages from path, VCS and other non-registry repositories are listed as skipped; where each package comes from is in package registries. composer update runs with --no-install --no-scripts --no-plugins, so no repository code runs. The PHP version constrains resolution; extension requirements do not, since they describe where the app is deployed, not the runner.

nix reads the flake.lock next to each flake.nix. Every direct input of the root flake is a dependency named after the input, such as nixpkgs, with its fully qualified root URL as the package (https://github.com/NixOS/nixpkgs) and the reference it was written with as the current value (github:NixOS/nixpkgs/nixos-unstable). Inputs that only follows another one have no lock of their own and are not dependencies. Transitive inputs move with the input that brings them in.

The Count asks nix what each reference points at now, with nix flake prefetch, and proposes the new revision as a digest update dated by the commit’s lastModified, so the release-age wait applies. The branch, patchula/nix-nixpkgs (patchula/nix-dev--nixpkgs for a flake in dev/), runs nix flake update nixpkgs, and the lock nix writes is the whole change; flake.nix is never edited. An input pinned to a tag or commit in its URL, such as github:numtide/flake-utils/v1.0.0, does not move, the same as with nix itself.

Inputs nix would fetch from outside the repository are skipped with a reason: path: and git+file: inputs that leave the repository, ssh URLs, plain http, and Mercurial. A path: input inside the repository changes with the repository, so it is skipped too. How nix runs, and how the inputs it fetches are checked, is under Lockfiles.

Every dependency has a kind, which rules can select: production, development, peer, optional and build for packages; action, reusable-workflow and runner for workflows, with GitLab CI includes and components as reusable-workflow; container-image; tool and toolchain for mise tools and pinned toolchains; go-directive; provider and module for Terraform; chart for Helm; template for Copier; flake-input for Nix; and transitive for a vulnerable lockfile-only package. Reference data also has the kind reference-data, on top of its own.