Skip to content
Back to skills

Bump Type

ASecurity

Derives the bump verdict and dominant Bump Type Determination row for commits since the base. Use when deciding a bump.

  • 2 stars
  • 0 votes
  • 0 copies
  • 0 views
  • Added November 11, 2026
ai-agentsgoshellbashgit

Security analysis

A100/100

Pro scans all 2 files and shows the line behind each finding

Scanned November 11, 2026

npx -y skills add brenpike/hivemind --skill bump-type --agent claude-code

Installs into .claude/skills of the current project.

Are you the author of Bump Type?

Add the live security badge to your README. It updates with every re-scan.

Security grade badge for Bump Type
[![Security: A — Skills Directory](https://www.skillsdirectory.com/api/skills/brenpike-bump-type/badge)](https://www.skillsdirectory.com/skills/brenpike-bump-type)

More formats (shields.io, HTML) on the badges page. Keep it an A: scan every change in CI with Pro.

Download with Pro
SKILL.md
---
name: bump-type
description: Derives the bump verdict and dominant Bump Type Determination row for commits since the base. Use when deciding a bump.
allowed-tools:
  - Bash(bash "${CLAUDE_PLUGIN_ROOT}/skills/bump-type/scripts/bump-type.sh" *)
  - Read(~/.claude/plugins/cache/brenpike/hivemind/**)
shell: bash
---

# Bump Type

Derive the version-bump verdict for the commits on the working branch since it diverged from
the base. This skill backs the `version_bump_decision` workflow state owned by
`hivemind:overlord`. The deterministic engine is the committed, READ-ONLY script
`${CLAUDE_PLUGIN_ROOT}/skills/bump-type/scripts/bump-type.sh`; this body is a thin navigator
that runs the script once and interprets its routing. The engine mutates NOTHING — it reads
the commit range, derives the verdict, and prints a routing decision.

## Division of labor

The engine owns ALL the mechanical arithmetic of
`${CLAUDE_PLUGIN_ROOT}/governance/versioning.md` (Bump Type Determination): the revert
pre-pass, the per-commit row mapping, and the dominant-row precedence. The engine alone is the
single source for that arithmetic; versioning.md keeps the row table and the two judgment
definitions; this skill does not restate them.

The caller keeps ONLY two judgments, both defined in
`${CLAUDE_PLUGIN_ROOT}/governance/versioning.md` (Bump Trigger):

- whether the change satisfies any Bump Trigger bullet — passed as `--bump-trigger yes|no`.
- whether the change matches one or more bullets of the "No bump is required by default"
  list — passed as `--no-bump-match yes|no`.

## Required Inputs

The caller resolves and passes these; the skill does not invent them.

- `base`: the resolved base branch per `${CLAUDE_PLUGIN_ROOT}/governance/workflow.md`
  (Framework Defaults). Passed as a plain ref name or a full commit id; revision-suffix syntax
  is rejected.
- `bump_trigger`: `yes` or `no` — the Bump Trigger judgment above.
- `no_bump_match`: `yes` or `no` — the "No bump is required by default" judgment above.
- `version_files` (optional): a list of repository paths that hold a version. When given, the
  engine also checks each file's version against the verdict. Omit it for the verdict alone.

## Procedure

1. **Execute the script** with one Bash call:
   ```bash
   bash "${CLAUDE_PLUGIN_ROOT}/skills/bump-type/scripts/bump-type.sh" <base> --bump-trigger <yes|no> --no-bump-match <yes|no> [--version-file <path>]...
   ```
   Pass `--version-file <path>` once per entry of `version_files`, and not at all when
   `version_files` is absent or empty. EXECUTE (do not Read) the script — it owns the
   deterministic read -> derive -> emit and the argument and commit-framing guards. It reads the
   commit range, and each version file at the base and at HEAD, and writes nothing.

2. **Interpret the result.** Exit 0: the script printed YAML routing lines on stdout —
   ```yaml
   dominant_row: MAJOR|MINOR|PATCH|NO_BUMP|NONE|MULTI
   verdict: bump_required|no_bump|ask_user
   bump_type: major|minor|patch|none
   rule_applied: <1-6>
   counts:
     major: <N>
     minor: <N>
     patch: <N>
     no_bump: <N>
   mapped_commits: <N>
   dropped_reverts: <N>
   version_check: match|mismatch|unreadable|undetermined   # only with --version-file
   trunk_version: X.Y.Z                                     # only with --version-file
   expected_version: X.Y.Z                                  # only with --version-file
   ```
   Route on `verdict`:
   - `bump_required` — a version bump is required; `bump_type` names the increment to assign.
   - `no_bump` — no version bump is required.
   - `ask_user` — the change matches more than one row, matches no row, or matches a row whose
     impact condition is unsatisfied. The caller surfaces the bump decision to the user before
     delegating any version edit.

   `rule_applied`, `counts`, `mapped_commits`, and `dropped_reverts` are evidence for the
   caller's report, not additional routing inputs.

   With `version_files`, three more keys follow:
   - `version_check` — `match`: every file holds `expected_version` at HEAD. `mismatch`: at
     least one does not. `unreadable`: a file has no version the engine can read at the base or
     at HEAD, or the files' base versions differ. `undetermined`: the verdict is `ask_user`, so
     no version is expected yet.
   - `trunk_version` — the files' shared version at the base. Present only when every base
     version reads and all agree.
   - `expected_version` — the version each file should hold: `trunk_version` raised by
     `bump_type` on `bump_required`, `trunk_version` itself on `no_bump`. Present only with
     `trunk_version` and one of those two verdicts.

   The engine reads a `*.json` file's top-level string `version`, the only `version = "X.Y.Z"`
   line of a `*.toml` file, and any other file as one version line. A version must be a plain
   `X.Y.Z`; a pre-release or any other form reads as no version.

   Exit 1: the script printed `blocker: <reason>` on stderr and nothing on stdout (for
   example: an invalid or unresolvable base, a missing, repeated, or invalid flag, a version
   file path that fails the identifier gate, a missing jq for a `*.json` version file, no git
   checkout, a missing shared library, a failed commit read, or a commit-framing violation) —
   surface it and stop.

## Pointers

- EXECUTE (do not read) the engine:
  `${CLAUDE_PLUGIN_ROOT}/skills/bump-type/scripts/bump-type.sh`.
- Rules the engine encodes: `${CLAUDE_PLUGIN_ROOT}/governance/versioning.md`
  (Bump Type Determination).

## Silence Discipline

Follow `${CLAUDE_PLUGIN_ROOT}/governance/definitions.md` (Silence Discipline). The only action
is the step 1 Bash call, where the procedure ends.

## Do Not

- hand-compute the revert pre-pass, row mapping, or dominant row — the script derives them
  from the commit range.
- pass a judgment the caller has not made — each flag is required and takes only `yes` or `no`.
- assign a bump type when `verdict` is `ask_user` — surface the decision to the user first.
- edit any version artifact — this skill only derives the verdict.
- mutate any file — this engine is read-only.
- commit, push, or open a PR.
- Read or reconstruct the script body — invoke it with the documented arguments.

Files in this skill

  • SKILL.md6.2 KB
  • scripts/bump-type.sh17.9 KB

Attribution

Is this your skill, or is something wrong with this listing? Request removal or report an issue. Author removals are honored within 72 hours.

View all in ai-agents →

Comments

Loading comments…

Newsletter

Get the weekly list of safe new skills, and the ones we pulled.