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.
JavaScript
Section titled “JavaScript”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.
GitHub Actions
Section titled “GitHub Actions”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.
actions.lock
Section titled “actions.lock”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.
Forgejo and Gitea Actions
Section titled “Forgejo and Gitea Actions”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, Go and Terraform
Section titled “Cargo, Go and Terraform”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
Section titled “Woodpecker”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
Section titled “Copier”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.
Containers and Kubernetes
Section titled “Containers and Kubernetes”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.
Python
Section titled “Python”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.
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.
GitLab CI
Section titled “GitLab CI”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, pre-commit and devcontainers
Section titled “Helm, pre-commit and devcontainers”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 and Gradle
Section titled “Maven and Gradle”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.
.NET, Ruby and PHP
Section titled “.NET, Ruby and PHP”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. A packages.lock.json
is not regenerated, because dotnet restore evaluates MSBuild code from the
repository and its packages: an update to a project with one is skipped with
that reason (see what is refused).
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 bundle lock runs in a scrubbed
environment that ignores any repository .bundle/config.
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.
© 2026 Sweepy
