From 9975a0d710543f9f841d833edb0fcb7036133d5a Mon Sep 17 00:00:00 2001 From: "aicia[bot]" Date: Mon, 8 Jun 2026 01:14:30 +0200 Subject: [PATCH 1/9] =?UTF-8?q?=E2=9C=A8=20introduce=20dotnet-change-impac?= =?UTF-8?q?t=20skill?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Add the dotnet-change-impact skill for classifying .NET library changes and recommending version bumps (Major/Minor/Patch) according to Microsoft's official compatibility rules. Includes SKILL.md, evals for benchmarking, and compatibility-categories reference. --- skills/dotnet-change-impact/SKILL.md | 305 ++++++++++++++++++ skills/dotnet-change-impact/evals/evals.json | 90 ++++++ .../references/compatibility-categories.md | 204 ++++++++++++ 3 files changed, 599 insertions(+) create mode 100644 skills/dotnet-change-impact/SKILL.md create mode 100644 skills/dotnet-change-impact/evals/evals.json create mode 100644 skills/dotnet-change-impact/references/compatibility-categories.md diff --git a/skills/dotnet-change-impact/SKILL.md b/skills/dotnet-change-impact/SKILL.md new file mode 100644 index 0000000..f8a2423 --- /dev/null +++ b/skills/dotnet-change-impact/SKILL.md @@ -0,0 +1,305 @@ +--- +name: dotnet-change-impact +description: > + Classifies proposed .NET library or NuGet package changes and recommends the correct release bump: Major, Minor, or Patch. Applies both Semantic Versioning (MAJOR.MINOR.PATCH) and .NET assembly/file versioning (Major.Minor.Build.Revision), grounded in Microsoft’s official .NET library compatibility rules. Use when evaluating breaking changes, API diffs, public API changes, dependency updates, TFM/platform support, interface or enum changes, overloads, analyzers, source generators, or binary/source/behavioral/design-time/backwards compatibility. Outputs only Major, Minor, or Patch when clear; otherwise provides structured compatibility reasoning. +--- + +# .NET Change Impact + +Classify a proposed change to a .NET library or NuGet package and recommend the correct +release bump. This skill exists to stop accidental breaking releases from being shipped as +a patch or minor, while staying practical enough not to label every internal refactor as +breaking. + +It answers one question: + +> Given these changes, should I bump **Major**, **Minor**, or **Patch**? + +The authority for every decision is Microsoft's official .NET compatibility guidance: + +- https://learn.microsoft.com/en-us/dotnet/core/compatibility/library-change-rules +- https://learn.microsoft.com/en-us/dotnet/core/compatibility/categories + +Treat those two sources as normative. When the deep category definitions or the long tail of +special cases matter, read `references/compatibility-categories.md`. + +## Critical: choose the output mode first + +Before answering, decide which mode applies. This choice is the most important behavior of the +skill, because the two modes look completely different to the user. + +### Deterministic mode + +Use this when the change is clear and unambiguous and a single bump obviously applies. Output +**exactly one** of the following words and **nothing else** — no markdown, no preamble, no +explanation, no trailing punctuation: + +```text +Major +``` + +```text +Minor +``` + +```text +Patch +``` + +The value of deterministic mode is that it can be dropped straight into a release pipeline, +a commit, or a script. Any extra prose defeats that purpose, so resist the urge to justify a +clear answer. + +### Explanation mode + +Use this when the answer is genuinely not clear-cut. Switch to explanation mode whenever any +of these is true: + +- The user asks for an explanation or asks "why". +- The input is ambiguous, incomplete, or mixed (several unrelated changes at once). +- More than one category is plausible and the deciding fact is missing. +- The decision depends on whether an API is **public or internal**. +- The decision depends on **consumer reliance**, or on documented vs. undocumented behavior. +- The decision depends on whether downstream projects treat **warnings as errors**. +- The user appears to be steering toward a lower bump than the change warrants. + +In explanation mode, do not collapse to a bare word. Surface the trade-off so the developer +can make an informed, deliberate call. Use the template in **Explanation output format** below. + +When in genuine doubt about which mode applies, prefer explanation mode. A bare word that hides +a real compatibility risk is worse than a short, honest analysis. + +## Internal analysis process + +Run this analysis internally for every request, regardless of which mode you output. Do **not** +print this checklist when deterministic output is possible — it is reasoning scaffolding, not +part of the answer. + +1. Identify all public contract changes (types, members, signatures, accessibility, contracts). +2. Identify all observable behavior changes (return values, exceptions, ordering, serialization). +3. Identify all source compatibility risks (would existing consumer code still compile?). +4. Identify all binary compatibility risks (would existing compiled consumers still load/run?). +5. Identify all design-time compatibility risks (analyzers, generators, build, tooling, restore). +6. Determine whether existing consumers remain backwards compatible end to end. +7. Determine the highest required bump across every change present. +8. If the result is clear, produce deterministic output. +9. If the result is ambiguous or an explanation was requested, produce explanatory output. + +## Version bump rules + +### Major — breaking or potentially breaking + +Recommend `Major` when the change can break, or plausibly break, existing consumers. A change +is breaking if it can affect backwards, binary, source, or design-time compatibility, or change +observable behavior that consumers can reasonably depend on. + +Changes that usually require `Major`: + +- Removing a public type, member, constructor, property, method, event, field, enum value, + attribute, or interface member. +- Renaming public APIs, or changing public method signatures. +- Changing parameter order, parameter types, return types, generic constraints, nullability + contracts, accessibility, or inheritance behavior. +- Making a public API less accessible. +- Making previously valid consumer code fail to compile, or previously compiled consumer + binaries fail at runtime. +- Changing observable behavior consumers can reasonably depend on: serialization, wire format, + persisted data format, exception behavior, ordering, equality, hashing, parsing, formatting, + validation, or default values, in a breaking way. +- Removing or reducing platform, TFM, runtime, OS, architecture, or dependency support. +- Introducing stricter validation that rejects previously accepted inputs — unless it is an + explicitly documented bug fix that is extremely unlikely to affect valid consumers. +- Changing public abstractions or interfaces so implementers must change code. +- Changing package identity, assembly identity, strong name, namespace, or binding expectations + in a way that affects existing consumers. + +### Minor — backward-compatible additions + +Recommend `Minor` when the change adds functionality without breaking source, binary, +design-time, or behavioral compatibility. + +Changes that usually require `Minor`: + +- Adding a new public type, method, property, constructor, overload, event, enum type, or + extension method that does not break existing compilation or behavior. +- Adding optional, opt-in capabilities, or new behavior behind opt-in configuration. +- Adding support for a new TFM, platform, runtime, OS, architecture, or dependency version + without removing existing support. +- Adding new package features while preserving existing contracts. +- Improving performance with no observable semantic breakage. +- Adding diagnostics, analyzers, or source generators that do not break builds by default. + +Be conservative with interfaces: adding members to an existing public interface is usually +breaking for implementers and therefore usually `Major`. Default interface implementations +reduce but do not eliminate source, design-time, and behavioral risk — evaluate them, do not +wave them through. + +### Patch — backward-compatible, no new public surface + +Recommend `Patch` when the change preserves the public contract and adds no new public +functionality. + +Changes that usually require `Patch`: + +- Bug fixes that preserve the intended public contract. +- Dependency updates that do not change the public API, supported TFMs, runtime behavior, or + compatibility guarantees. +- Security fixes that preserve compatibility. +- Internal implementation changes and refactoring with no public or behavioral impact. +- Documentation updates; build, packaging, CI, test, or housekeeping changes. +- Non-breaking performance improvements; non-breaking analyzer or warning changes. + +Key nuance: a bug fix can still be breaking. If the fix changes observable behavior, exception +behavior, serialization, validation, ordering, equality, formatting, parsing, threading, +timing, or side effects that consumers may depend on, evaluate it as a potential `Major`. + +## Precedence rules + +When several changes ship together, choose the **highest** required bump: + +```text +Major > Minor > Patch +``` + +- One breaking change plus several bug fixes → `Major`. +- One backward-compatible feature plus several patches → `Minor`. +- Only housekeeping and bug fixes → `Patch`. + +## Conservative decision policy + +When uncertain, prefer the safer classification: + +- If a change might break existing consumers, recommend `Major`. +- If a change only adds backward-compatible functionality, recommend `Minor`. +- If a change only fixes or maintains existing behavior, recommend `Patch`. + +But do not inflate every behavior change to `Major`. First decide whether the behavior is +actually observable, documented, reasonably relied upon, or compatibility-sensitive. An +internal or non-observable change is not a breaking change just because something changed. + +## Compatibility classification + +When you produce an explanation, classify the impact using these five categories. Full, +Microsoft-grounded definitions and examples live in `references/compatibility-categories.md`; +the summary here is enough for most decisions. + +- **Behavioral change** — the API still compiles and loads, but observable behavior differs + (return values, exceptions, validation, ordering, equality/hash, serialization, formatting, + side effects, threading/timing/caching). Can be breaking even when binary and source + compatibility are intact. +- **Binary compatibility** — existing compiled assemblies may fail against the new version + without recompilation (removed members, changed signatures, changed assembly identity, + changed type shape). Usually implies `Major`. +- **Source compatibility** — existing source must change to compile (renames, signature + changes, removals, new constraints, ambiguous overloads, changed accessibility/nullability, + required language/TFM bumps). Usually implies `Major`. +- **Design-time compatibility** — build, tooling, analyzers, generators, project system, IDE, + or restore behavior changes (new default-on analyzer errors, changed generator output, + build/props/targets changes, SDK/tooling requirements). May imply `Major` if it breaks + existing consumers by default. +- **Backwards compatibility** — the end-to-end test: can existing consumers of the old version + use the new version unmodified, with equivalent behavior? If they cannot compile, run, or + build, or they observe a breaking behavior change, it is not backwards compatible and usually + requires `Major`. + +## Special cases + +These recur often enough to call out directly. The full catalog is in +`references/compatibility-categories.md`. + +- **Dependency updates** — default `Patch`. Escalate to `Minor` or `Major` only if the update + changes public API exposure, supported TFMs/platforms, runtime behavior, introduces + binding/runtime incompatibility, requires consumers to update their own dependencies, or + drops compatibility with existing consumers. +- **Bug fixes** — default `Patch`. If the old, incorrect behavior was publicly observable and + consumers may depend on it, explain the trade-off; it may still need `Major`. +- **New overloads** — usually `Minor`, but check for overload-resolution ambiguity. If existing + source could bind differently or fail to compile, consider `Major`. +- **Interface changes** — adding members to a public interface is usually `Major` (implementers + may fail to compile). Adding a brand-new interface is usually `Minor`. Default interface + members still warrant caution and explanation. +- **Enum changes** — adding values is usually `Minor`, but may be behavioral or source-impacting + if consumers exhaustively switch over values or serialization contracts are affected. Removing + or renaming values is usually `Major`. +- **Analyzer / source generator / build changes** — warnings-only diagnostics that do not break + default builds are usually `Patch` or `Minor` by scope. Diagnostics that become errors by + default, or generated-code changes that break consumers, are usually `Major`. +- **TFM / platform support** — adding support is usually `Minor`; removing support is usually + `Major`. Raising the minimum supported runtime, SDK, language version, OS, or CPU architecture + is usually `Major` when existing consumers are affected. +- **Performance changes** — usually `Patch` when behavior is unchanged; may be `Major` when + timing, ordering, threading, concurrency, caching, resource lifetime, or side effects are + observable and compatibility-sensitive. + +## SemVer and .NET version-number mapping + +### Semantic Versioning — `MAJOR.MINOR.PATCH` + +- `Major` → increment Major, reset Minor and Patch to `0`. +- `Minor` → increment Minor, reset Patch to `0`. +- `Patch` → increment Patch. + +### .NET assembly/file versioning — `Major.Minor.Build.Revision` + +- `Major` → increment Major. Reset or align Minor per project policy. +- `Minor` → increment Minor. +- `Patch` → normally maps to Build or Revision per project policy. +- `Build` and `Revision` are CI/build metadata. Never use them to hide a breaking change, and + do not use them as a substitute for a SemVer Patch when NuGet package versioning is involved. + +## Input interpretation + +Input may arrive as release notes, git commits, PR summaries, API diffs, changelog entries, +dependency updates, bug-fix descriptions, or a stated release intent. Distinguish carefully +between: public API changes, internal implementation changes, consumer-visible behavior +changes, build/design-time changes, documentation-only changes, package/dependency changes, +and platform/TFM support changes. The bump follows the most impactful real change, not the +loudest commit subject. + +## Explanation output format + +When explanation mode applies, use exactly this structure: + +```markdown +## Recommendation + + + +## Compatibility impact + +- Behavioral change: — +- Binary compatibility: — +- Source compatibility: — +- Design-time compatibility: — +- Backwards compatibility: — + +## Reasoning + + + +## Deterministic decision + + +``` + +## Good output characteristics + +- Emits exactly one word in deterministic mode, with no decoration. +- Switches to the structured template the moment the decision is genuinely ambiguous or an + explanation is requested. +- Picks the highest required bump when changes are mixed. +- Grounds every breaking-change call in whether existing consumers can compile, run, and + observe equivalent behavior. +- Stays conservative on interface and behavioral risk without inflating internal-only changes. + +## Bad output characteristics + +- Adding prose, markdown, or punctuation around a clear one-word answer. +- Collapsing an ambiguous or mixed change into a bare word that hides a compatibility risk. +- Labeling a publicly observable behavior change as `Patch` just because it is "a fix". +- Calling an internal, non-observable refactor `Major`. +- Hiding a breaking change behind a Build/Revision bump. +- Inventing compatibility guarantees or migration steps the input does not support. diff --git a/skills/dotnet-change-impact/evals/evals.json b/skills/dotnet-change-impact/evals/evals.json new file mode 100644 index 0000000..ffe4014 --- /dev/null +++ b/skills/dotnet-change-impact/evals/evals.json @@ -0,0 +1,90 @@ +{ + "skill_name": "dotnet-change-impact", + "evals": [ + { + "id": 1, + "prompt": "In my .NET library I removed the public method `HttpRetryHandler.Send(HttpRequestMessage)` and renamed the public property `Client.BaseUri` to `Client.BaseAddress`. Should I bump major, minor, or patch?", + "expected_output": "Deterministic single-word answer: Major.", + "expectations": [ + "Outputs exactly the single word Major with no markdown, preamble, or extra prose", + "Does not add an explanation, since the breaking removal and public rename are unambiguous", + "Treats removing a public method and renaming a public property as binary and source breaking" + ] + }, + { + "id": 2, + "prompt": "I added a brand-new public class `RetryPolicy` and a new `WithRetry(this HttpClient client, int attempts)` extension method to my NuGet package. No existing public APIs were touched. What's the version bump?", + "expected_output": "Deterministic single-word answer: Minor.", + "expectations": [ + "Outputs exactly the single word Minor with no extra text", + "Recognizes purely additive, backward-compatible public surface as Minor", + "Does not escalate to Major when nothing existing was changed or removed" + ] + }, + { + "id": 3, + "prompt": "This release only fixes a NullReferenceException inside an internal cache class (no public API or observable behavior change), updates a transitive dependency from 8.0.1 to 8.0.3, and refreshes the README. Major, minor, or patch?", + "expected_output": "Deterministic single-word answer: Patch.", + "expectations": [ + "Outputs exactly the single word Patch with no extra text", + "Treats internal-only fix, compatible patch dependency bump, and docs as non-breaking", + "Does not inflate an internal, non-observable refactor to Minor or Major" + ] + }, + { + "id": 4, + "prompt": "I changed `DateParser.Parse` to throw a FormatException on empty input instead of returning null. Should this be a patch? It's just a bug fix.", + "expected_output": "Explanation-mode answer: ambiguous because it depends on whether Parse is public and whether consumers rely on the null-return behavior. Should not just say Patch.", + "expectations": [ + "Switches to explanation mode instead of emitting a bare single word", + "Uses the structured template with Recommendation, Compatibility impact, Reasoning, and Deterministic decision sections", + "Flags this as a behavioral change that can be breaking even though it compiles", + "Does not accept the user's framing that a bug fix is automatically a Patch", + "Identifies the deciding fact: whether Parse is public and whether the old null-return behavior is relied upon or documented" + ] + }, + { + "id": 5, + "prompt": "Big release: I added two new public extension methods, fixed a couple of internal bugs, AND removed a public `ILogger` overload that nobody should be using. One command answer please: major, minor, or patch?", + "expected_output": "Deterministic single-word answer: Major, because precedence picks the highest required bump and the public removal is breaking.", + "expectations": [ + "Outputs exactly the single word Major", + "Applies precedence: the breaking public removal dominates the additive and internal changes", + "Does not downgrade to Minor or Patch despite the user implying the removed overload is unused" + ] + }, + { + "id": 6, + "prompt": "I added a new member `Task FlushAsync()` to my public interface `IMessageSink`. Existing implementations are out in the wild via my NuGet package. Why would this be more than a patch?", + "expected_output": "Explanation-mode answer recommending Major, explaining that adding a member to a public interface breaks existing implementers (source compatibility).", + "expectations": [ + "Switches to explanation mode because the user asked why", + "Recommends Major", + "Explains that adding a member to an existing public interface breaks existing implementers' source compilation", + "Mentions default interface members as a nuance without treating them as automatically safe", + "Uses the structured explanation template" + ] + }, + { + "id": 7, + "prompt": "I added a new enum value `LogLevel.Trace` to an existing public enum. My library serializes these values to JSON and some consumers switch over them. Patch, minor, or major?", + "expected_output": "Explanation-mode answer: usually Minor but flag the exhaustive-switch and serialization-contract risk that could make it behavioral/source-impacting.", + "expectations": [ + "Does not emit a bare one-word answer given the explicit switch and serialization caveats", + "Notes that adding an enum value is usually Minor", + "Flags exhaustive consumer switch statements and serialization contracts as escalation risks", + "Uses the structured explanation template with a clear recommendation" + ] + }, + { + "id": 8, + "prompt": "My library dropped support for net6.0 and now targets only net8.0 and net9.0. Existing consumers on net6.0 will be affected. Version bump?", + "expected_output": "Deterministic single-word answer: Major, because removing TFM/platform support is breaking for existing consumers.", + "expectations": [ + "Outputs exactly the single word Major", + "Treats removing TFM support as breaking for existing consumers", + "Does not classify dropped framework support as Minor or Patch" + ] + } + ] +} diff --git a/skills/dotnet-change-impact/references/compatibility-categories.md b/skills/dotnet-change-impact/references/compatibility-categories.md new file mode 100644 index 0000000..5e3be41 --- /dev/null +++ b/skills/dotnet-change-impact/references/compatibility-categories.md @@ -0,0 +1,204 @@ +# .NET Compatibility Categories — Reference + +Detailed, Microsoft-grounded definitions for the five compatibility categories and the full +catalog of special cases. `SKILL.md` carries the decision engine and summaries; consult this +file when a decision hinges on a nuanced category boundary or an uncommon change shape. + +Normative sources: + +- [Library change rules](https://learn.microsoft.com/en-us/dotnet/core/compatibility/library-change-rules) +- [Compatibility categories](https://learn.microsoft.com/en-us/dotnet/core/compatibility/categories) + +## Table of contents + +1. The five categories in depth +2. Why a change can be breaking even when it compiles +3. Special-case catalog +4. Worked classification examples + +## 1. The five categories in depth + +### Behavioral change + +The public API surface is unchanged — it still compiles against and loads against existing +consumers — but the **observable behavior** differs. This is the category developers most often +under-weight, because nothing in the signature changed. + +Observable behavior includes: + +- Different return values for the same inputs. +- Different exceptions thrown, or exceptions thrown where none were before (and vice versa). +- Different input validation (stricter or looser). +- Different ordering of results (collections, enumerations, query output). +- Different equality or hash-code behavior. +- Different serialization, deserialization, or formatting output. +- Different side effects (files written, events raised, state mutated). +- Different threading, timing, caching, retry, or I/O behavior. + +A behavioral change is breaking when consumers can reasonably depend on the old behavior. It can +be breaking even when binary and source compatibility are fully intact, which is why a "bug fix" +is not automatically a `Patch`. + +### Binary compatibility + +Existing **compiled** consumer assemblies must continue to run against the new version without +recompilation. A change is binary-incompatible when a previously compiled consumer could fail to +load or fail at runtime against the new assembly. Examples: + +- Removing or renaming public members. +- Changing method signatures, return types, or parameter types. +- Changing assembly identity (name, version policy, strong name, public key). +- Changing the shape of a public field, property, event, or method. +- Changing base classes or interface contracts that compiled consumers rely on. + +Binary incompatibility almost always implies `Major`. + +### Source compatibility + +Existing consumer **source code** must continue to compile against the new version without edits. +A change is source-incompatible when previously valid consumer code would no longer compile: + +- Renamed or removed APIs. +- Changed signatures or required new arguments. +- New generic constraints. +- Newly ambiguous overloads (overload resolution now fails). +- Reduced accessibility (e.g., `public` → `internal`). +- Changed nullability annotations that break `enable` consumers, or + analyzer behavior that breaks strict builds. +- A required higher C# language version or TFM. + +Source incompatibility usually implies `Major`. Note the asymmetry: a change can be binary +compatible but source incompatible (e.g., adding an ambiguous overload), or source compatible +but binary incompatible. Evaluate both. + +### Design-time compatibility + +The change affects build, tooling, analyzers, source generators, the project system, the IDE +experience, package restore, or compile-time diagnostics — rather than runtime behavior: + +- New analyzer diagnostics that are **errors by default**. +- Source generator output changes that alter or break generated code. +- Changes to MSBuild targets/props shipped in the package. +- Package restore behavior changes. +- New SDK, workload, or tooling requirements. +- Design-time build failures. + +Design-time incompatibility may imply `Major` when existing consumers are broken by default +(for example, a build that previously succeeded now fails). Warnings-only changes that do not +break a default build are usually lower impact. + +### Backwards compatibility + +This is the synthesizing question, not a separate mechanism: **can an existing consumer of the +old version adopt the new version with no modifications and get equivalent behavior?** If the +consumer cannot compile, cannot run, fails at design time, or observes a breaking behavior +change, the release is not backwards compatible and usually requires `Major`. Use this category +to summarize the combined effect of the other four. + +## 2. Why a change can be breaking even when it compiles + +The most common misclassification is treating "the public API didn't change" as "this is safe". +Microsoft's guidance is explicit that behavioral changes are a first-class compatibility concern. +When evaluating any fix, refactor, or performance improvement, ask: + +- Could a reasonable consumer have written code that depends on the **old** observable behavior? +- Is the old behavior documented, or is it an undocumented implementation detail? +- Does the change alter exceptions, ordering, equality, serialization, validation, timing, or + side effects? + +If the answer points to real consumer reliance, escalate from `Patch` toward `Major`, and +prefer explanation mode so the trade-off is visible. + +## 3. Special-case catalog + +### Dependency updates + +Default `Patch`. Escalate when the dependency update: + +- changes the library's own public API exposure (re-exported types, transitively visible APIs), +- changes supported TFMs or platforms, +- changes runtime behavior consumers can observe, +- introduces a binding or runtime incompatibility, +- forces consumers to update their own references to that dependency, +- removes compatibility with existing consumers. + +If any apply, evaluate as `Minor` (additive, compatible) or `Major` (breaking). + +### Bug fixes + +Default `Patch`. But a bug fix that changes publicly observable behavior may be breaking even +though the fix is "correct". If the old behavior was clearly wrong yet observable, explain the +trade-off; depending on consumer reliance it may still require `Major`. The correctness of the +fix does not by itself make it non-breaking. + +### New overloads + +Usually `Minor`. The risk is **source compatibility**: a new overload can make a previously +unambiguous call ambiguous, or change overload resolution so existing source binds to a different +method or fails to compile. When that risk is real, consider `Major`. + +### Interface changes + +- Adding members to an existing public interface → usually `Major` (existing implementers fail to + compile). +- Adding a brand-new interface → usually `Minor`. +- Adding a **default interface member** → lower source-break risk for implementers, but still + carries source, design-time, and behavioral risk depending on language version, multiple + inheritance of members, and runtime support. Do not treat it as automatically safe — evaluate + and explain. + +### Enum changes + +- Adding enum values → usually `Minor`. But it can be behavioral or source-impacting if consumers + exhaustively `switch` over the values (e.g., with no default arm) or if serialization contracts + depend on the closed set. +- Removing or renaming enum values → usually `Major`. +- Changing the underlying numeric value of an existing member → usually `Major` (binary and + serialization impact). + +### Analyzer / source generator / build changes + +- New diagnostics that are warnings only and do not break default builds → usually `Patch` or + `Minor` depending on feature scope. +- Diagnostics promoted to errors by default → usually `Major` (breaks builds that previously + succeeded). +- Source generator output changes that break or materially alter consumer-visible generated code + → usually `Major`. + +### TFM / platform support + +- Adding support for a new TFM, platform, runtime, OS, or architecture → usually `Minor`. +- Removing support → usually `Major`. +- Raising the minimum supported runtime, SDK, C# language version, OS, or CPU architecture → + usually `Major` when existing consumers are affected. + +### Performance changes + +Usually `Patch` when behavior is unchanged. Escalate toward `Major` when timing, ordering, +threading, concurrency, caching, resource lifetime, or other side effects become observable and +compatibility-sensitive (for example, a change from synchronous to lazy evaluation that alters +when exceptions surface). + +## 4. Worked classification examples + +**Example 1 — clear Major** +Input: "Removed the obsolete `LegacyClient.Connect(string)` overload and renamed `IParser.Read` +to `IParser.ReadAll`." +Output: `Major`. Removal plus a rename of a public interface member breaks binary and source +compatibility, and forces implementers to change code. + +**Example 2 — clear Minor** +Input: "Added a new `RetryPolicy` class and a `WithRetry(...)` extension method; existing APIs +unchanged." +Output: `Minor`. Purely additive, backward-compatible public surface. + +**Example 3 — clear Patch** +Input: "Fixed a NullReferenceException in an internal cache; no public API or observable behavior +change. Updated a transitive dependency patch version." +Output: `Patch`. Internal fix plus a compatible dependency bump. + +**Example 4 — ambiguous, needs explanation** +Input: "Tightened `Parse` to reject empty strings instead of returning null." +This depends on whether `Parse` is public, whether returning null was documented, and whether +consumers rely on it. The deciding fact is the API's visibility and documented contract — surface +that in explanation mode rather than guessing. From 5ef5d536924c5d2120cf6e10ff41a7abfe6375b0 Mon Sep 17 00:00:00 2001 From: "aicia[bot]" Date: Mon, 8 Jun 2026 01:14:37 +0200 Subject: [PATCH 2/9] =?UTF-8?q?=F0=9F=92=AC=20register=20dotnet-change-imp?= =?UTF-8?q?act=20in=20skill=20index?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Update README.md to list dotnet-change-impact in the Available Skills section with install command and detailed description. Add a new 'Why dotnet-change-impact?' section explaining the skill's purpose, grounding in Microsoft's compatibility model, and key capabilities. --- README.md | 40 +++++++++++++++++++++++++++++++--------- 1 file changed, 31 insertions(+), 9 deletions(-) diff --git a/README.md b/README.md index 55afa62..6b96eaf 100644 --- a/README.md +++ b/README.md @@ -61,7 +61,8 @@ npx skills add https://github.com/codebeltnet/agentic --skill trunk-first-repo npx skills add https://github.com/codebeltnet/agentic --skill dotnet-strong-name-signing npx skills add https://github.com/codebeltnet/agentic --skill dotnet-new-app-slnx npx skills add https://github.com/codebeltnet/agentic --skill dotnet-new-lib-slnx -npx skills add https://github.com/codebeltnet/agentic --skill git-remote-release +npx skills add https://github.com/codebeltnet/agentic --skill git-remote-release +npx skills add https://github.com/codebeltnet/agentic --skill dotnet-change-impact # npx skills add https://github.com/codebeltnet/agentic --skill another-skill ``` @@ -94,6 +95,7 @@ npx skills add https://github.com/codebeltnet/agentic --skill git-remote-release | [trunk-first-repo](skills/trunk-first-repo/SKILL.md) | Initialize a git repository following [scaled trunk-based development](https://trunkbaseddevelopment.com/#scaled-trunk-based-development). Seeds an empty `main` branch and creates a versioned feature branch (`v0.1.0/init`), enforcing a PR-first workflow where content only reaches main through peer-reviewed pull requests. | | [dotnet-strong-name-signing](skills/dotnet-strong-name-signing/SKILL.md) | Generate a strong name key (`.snk`) file for signing .NET assemblies using pure .NET cryptography — no Visual Studio Developer PowerShell or `sn.exe` required. Works in any terminal. Defaults to 1024-bit RSA (matching `sn.exe`), with 2048 and 4096 available as options. | | [git-remote-release](skills/git-remote-release/SKILL.md) | Generate GitHub release notes by summarizing all commits and pull requests between two Git tags or branches in a remote GitHub repository. Accepts a compare URL or separate owner/repo, previous ref, and current ref values; falls back to comparing the current branch against the upstream default branch when no input is provided. Produces a human-friendly `## What's Changed` summary with optional GitHub alert blocks, a `Sources:` section preserving PR and commit references, and a full changelog compare link. | +| [dotnet-change-impact](skills/dotnet-change-impact/SKILL.md) | Classify a proposed .NET library or NuGet package change and recommend the correct release bump — `Major`, `Minor`, or `Patch` — for both Semantic Versioning (`MAJOR.MINOR.PATCH`) and .NET assembly/file versioning (`Major.Minor.Build.Revision`), grounded in Microsoft's official .NET compatibility rules. Outputs exactly one word in deterministic mode when the change is clear, or a structured behavioral/binary/source/design-time/backwards compatibility analysis when the change is ambiguous, mixed, depends on public-vs-internal scope, or the user asks "why". Conservative by design so breaking changes never slip out as a patch or minor, without inflating internal-only refactors. | ### Copyable Install Commands @@ -171,12 +173,18 @@ npx skills add https://github.com/codebeltnet/agentic --skill trunk-first-repo npx skills add https://github.com/codebeltnet/agentic --skill dotnet-strong-name-signing ``` -`git-remote-release` - -```bash -npx skills add https://github.com/codebeltnet/agentic --skill git-remote-release -``` - +`git-remote-release` + +```bash +npx skills add https://github.com/codebeltnet/agentic --skill git-remote-release +``` + +`dotnet-change-impact` + +```bash +npx skills add https://github.com/codebeltnet/agentic --skill dotnet-change-impact +``` + ### Why git-visual-commits? Commit messages are the most-read documentation in any codebase — yet they're usually an afterthought. "fix stuff", "wip", "address PR feedback" tells you nothing six months later. Writing good commits takes discipline, and when you're in flow, it's the first thing that slips. @@ -494,8 +502,22 @@ Writing release notes is tedious. Raw commit logs are too noisy, PR titles often - **Source preservation** where every release note includes a `Sources:` section with the original PR and commit references, - **Strict format** that always starts with `## What's Changed` and always ends with the full changelog compare link, - **No invented claims** so every statement in the summary is backed by the commits and pull requests collected, -- **Read-only operation** that never mutates repository state. - +- **Read-only operation** that never mutates repository state. + +### Why dotnet-change-impact? + +Picking the wrong version number is one of the easiest ways to break downstream consumers. A "bug fix" that quietly changes exception behavior, an "innocent" new overload that makes existing calls ambiguous, or a dependency bump that drops a target framework — any of these can be a breaking change shipped as a patch. Conversely, teams sometimes panic and burn a major version on a purely internal refactor. **dotnet-change-impact** brings Microsoft's official .NET compatibility model to that decision. + +**dotnet-change-impact** reads a description of one or more proposed changes and recommends `Major`, `Minor`, or `Patch` for both SemVer and .NET `Major.Minor.Build.Revision` versioning. + +- **Two-mode output** — emits exactly one word (`Major`, `Minor`, or `Patch`) when the change is unambiguous, so it drops straight into a pipeline, or a structured analysis when the call is genuinely close, +- **Grounded in Microsoft guidance** — decisions follow the official [library change rules](https://learn.microsoft.com/en-us/dotnet/core/compatibility/library-change-rules) and [compatibility categories](https://learn.microsoft.com/en-us/dotnet/core/compatibility/categories), +- **Five-category compatibility lens** — behavioral, binary, source, design-time, and backwards compatibility are evaluated explicitly, +- **Conservative by default** — a change that might break existing consumers is treated as breaking, so accidental breaking releases don't ship as a patch or minor, +- **But not alarmist** — internal, non-observable refactors are not inflated to major just because something changed, +- **Precedence-aware** — mixed releases take the highest required bump, +- **Special-case savvy** — dependency updates, bug fixes, new overloads, interface and enum changes, analyzers/source generators, TFM/platform support, and performance changes each get the right default and the right escalation triggers. + ## Repository structure ``` From 7fecc855401e9fb49cbd749aa96ee063e5bd16d0 Mon Sep 17 00:00:00 2001 From: "aicia[bot]" Date: Mon, 8 Jun 2026 01:34:50 +0200 Subject: [PATCH 3/9] =?UTF-8?q?=E2=99=BB=EF=B8=8F=20enhance=20dotnet-chang?= =?UTF-8?q?e-impact=20with=20default=20git=20resolution?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Add comprehensive default resolution behavior when no explicit change details or compare range are provided. The skill now inspects the current Git branch and automatically compares it against the upstream default branch, collecting commits and net diff. Includes detailed guidance on input modes, git detection logic, fallback chain for branch resolution, and read-only commands. Updated evals to cover branch-detection scenarios and current-branch classification. --- skills/dotnet-change-impact/SKILL.md | 132 ++++++++++++++++--- skills/dotnet-change-impact/evals/evals.json | 30 +++-- 2 files changed, 135 insertions(+), 27 deletions(-) diff --git a/skills/dotnet-change-impact/SKILL.md b/skills/dotnet-change-impact/SKILL.md index f8a2423..f271c93 100644 --- a/skills/dotnet-change-impact/SKILL.md +++ b/skills/dotnet-change-impact/SKILL.md @@ -1,8 +1,8 @@ --- name: dotnet-change-impact -description: > - Classifies proposed .NET library or NuGet package changes and recommends the correct release bump: Major, Minor, or Patch. Applies both Semantic Versioning (MAJOR.MINOR.PATCH) and .NET assembly/file versioning (Major.Minor.Build.Revision), grounded in Microsoft’s official .NET library compatibility rules. Use when evaluating breaking changes, API diffs, public API changes, dependency updates, TFM/platform support, interface or enum changes, overloads, analyzers, source generators, or binary/source/behavioral/design-time/backwards compatibility. Outputs only Major, Minor, or Patch when clear; otherwise provides structured compatibility reasoning. ---- +description: > + Classifies .NET library or NuGet package changes and recommends the correct release bump: Major, Minor, or Patch. Applies both Semantic Versioning (MAJOR.MINOR.PATCH) and .NET assembly/file versioning (Major.Minor.Build.Revision), grounded in Microsoft’s official .NET library compatibility rules. Use when evaluating the current branch, breaking changes, API diffs, public API changes, dependency updates, TFM/platform support, interface or enum changes, overloads, analyzers, source generators, or binary/source/behavioral/design-time/backwards compatibility. When no explicit change details or compare range are provided, inspects the current Git branch and compares it against the upstream default branch automatically. Outputs only Major, Minor, or Patch when clear; otherwise provides structured compatibility reasoning. +--- # .NET Change Impact @@ -15,17 +15,113 @@ It answers one question: > Given these changes, should I bump **Major**, **Minor**, or **Patch**? -The authority for every decision is Microsoft's official .NET compatibility guidance: +The authority for every decision is Microsoft's official .NET compatibility guidance: - https://learn.microsoft.com/en-us/dotnet/core/compatibility/library-change-rules - https://learn.microsoft.com/en-us/dotnet/core/compatibility/categories -Treat those two sources as normative. When the deep category definitions or the long tail of -special cases matter, read `references/compatibility-categories.md`. - -## Critical: choose the output mode first - -Before answering, decide which mode applies. This choice is the most important behavior of the +Treat those two sources as normative. When the deep category definitions or the long tail of +special cases matter, read `references/compatibility-categories.md`. + +## Input + +The skill accepts input in three ways, checked in this order: + +**1. Explicit change details:** + +When the user provides release notes, a PR summary, an API diff, a git diff, a changelog entry, +dependency update details, a bug-fix description, or a stated release intent, classify those +provided changes directly. + +**2. Explicit compare range:** + +When the user provides a base ref, current ref, compare URL, branch name, tag range, or commit +range, inspect that range and classify the changes found there. + +**3. Default resolution (no input provided):** + +When the user does not provide explicit change details or a compare range, operate on the +current Git working repository. See **Default Resolution Behavior** below. + +If required information is missing and cannot be inferred or resolved, ask only for the missing +fact. Do not ask the user to restate the whole change set when the current repository or an +explicit compare range can be inspected. + +## Default Resolution Behavior + +If the user does not provide explicit change details, a compare URL, branch name, tag range, or +commit range, the skill must operate on the current Git working repository. + +In that case, the skill must: + +1. Detect the current branch. +2. Detect the upstream remote for the repository. +3. Detect the upstream repository's default branch — usually `main`, but do not assume `main` if + the remote default branch can be resolved. +4. Compare the current branch against the upstream remote default branch. +5. Include all commits on the current branch that are not present in the upstream remote default + branch. +6. Include the net diff for the comparison range, because compatibility impact often depends on + files changed, signatures, project metadata, target frameworks, package references, generated + assets, and build props/targets. +7. Classify the release bump from the collected branch changes using the normal compatibility + rules. + +The default comparison should be conceptually equivalent to: + +```text +upstream/default-branch...current-branch +``` + +For example, if the current branch is `feature/change-impact` and the upstream default branch is +`main`, the comparison should be treated as: + +```text +upstream/main...feature/change-impact +``` + +If the repository uses `origin` as the upstream remote, use: + +```text +origin/main...current-branch +``` + +If the repository has both `origin` and `upstream`, prefer the remote that represents the +canonical source repository. In fork-based workflows, this is usually `upstream`. In +single-repository workflows, this is usually `origin`. + +The skill must not silently assume the wrong base branch. If the default branch cannot be +resolved, fall back in this order: + +1. `origin/HEAD` +2. `upstream/HEAD` +3. `origin/main` +4. `origin/master` +5. `upstream/main` +6. `upstream/master` + +If none of these can be resolved, ask the user to provide the base branch or compare range. + +Useful read-only commands for default resolution: + +```bash +git rev-parse --abbrev-ref HEAD +git remote +git symbolic-ref refs/remotes/origin/HEAD --short +git symbolic-ref refs/remotes/upstream/HEAD --short +git merge-base HEAD {resolvedBase} +git log --oneline {resolvedBase}..HEAD +git log --format="%H%x09%an%x09%ae%x09%s%x09%b" {resolvedBase}..HEAD +git diff --name-status {resolvedBase}...HEAD +git diff --find-renames {resolvedBase}...HEAD +``` + +Use local Git state only for default resolution unless the user explicitly asks to refresh remote +state. Do not fetch, pull, push, or mutate repository state as part of this skill. + +## Critical: choose the output mode first + +Before answering, decide which mode applies. This choice is the most important behavior of the skill, because the two modes look completely different to the user. ### Deterministic mode @@ -247,14 +343,14 @@ These recur often enough to call out directly. The full catalog is in - `Build` and `Revision` are CI/build metadata. Never use them to hide a breaking change, and do not use them as a substitute for a SemVer Patch when NuGet package versioning is involved. -## Input interpretation - -Input may arrive as release notes, git commits, PR summaries, API diffs, changelog entries, -dependency updates, bug-fix descriptions, or a stated release intent. Distinguish carefully -between: public API changes, internal implementation changes, consumer-visible behavior -changes, build/design-time changes, documentation-only changes, package/dependency changes, -and platform/TFM support changes. The bump follows the most impactful real change, not the -loudest commit subject. +## Input interpretation + +Input may arrive as release notes, git commits, PR summaries, API diffs, changelog entries, +dependency updates, bug-fix descriptions, a stated release intent, or the default current-branch +comparison. Distinguish carefully between: public API changes, internal implementation changes, +consumer-visible behavior changes, build/design-time changes, documentation-only changes, +package/dependency changes, and platform/TFM support changes. The bump follows the most +impactful real change, not the loudest commit subject. ## Explanation output format diff --git a/skills/dotnet-change-impact/evals/evals.json b/skills/dotnet-change-impact/evals/evals.json index ffe4014..46c55ed 100644 --- a/skills/dotnet-change-impact/evals/evals.json +++ b/skills/dotnet-change-impact/evals/evals.json @@ -76,15 +76,27 @@ "Uses the structured explanation template with a clear recommendation" ] }, - { - "id": 8, - "prompt": "My library dropped support for net6.0 and now targets only net8.0 and net9.0. Existing consumers on net6.0 will be affected. Version bump?", - "expected_output": "Deterministic single-word answer: Major, because removing TFM/platform support is breaking for existing consumers.", + { + "id": 8, + "prompt": "My library dropped support for net6.0 and now targets only net8.0 and net9.0. Existing consumers on net6.0 will be affected. Version bump?", + "expected_output": "Deterministic single-word answer: Major, because removing TFM/platform support is breaking for existing consumers.", "expectations": [ "Outputs exactly the single word Major", "Treats removing TFM support as breaking for existing consumers", - "Does not classify dropped framework support as Minor or Patch" - ] - } - ] -} + "Does not classify dropped framework support as Minor or Patch" + ] + }, + { + "id": 9, + "prompt": "Use dotnet-change-impact to classify the version bump for this branch.", + "expected_output": "Current-branch default-resolution behavior: inspect the local Git repository, resolve the current branch against the upstream/default base branch, collect commits and net diff, then classify those changes. Must not ask the user to provide change details first.", + "expectations": [ + "Follows Default Resolution Behavior when no explicit change details or compare range are provided", + "Detects the current branch and resolves a base branch using local Git state, following the documented fallback order", + "Collects both branch commits and net diff before classifying compatibility impact", + "Does not respond with a generic request for release notes, diffs, PR summaries, or bug descriptions when the current repository can be inspected", + "Asks only for the missing base branch or compare range if local default resolution cannot identify one" + ] + } + ] +} From 6670602251e6b769872014b1970a27e0915ce944 Mon Sep 17 00:00:00 2001 From: "aicia[bot]" Date: Mon, 8 Jun 2026 01:34:55 +0200 Subject: [PATCH 4/9] =?UTF-8?q?=F0=9F=92=AC=20update=20dotnet-change-impac?= =?UTF-8?q?t=20description=20in=20skill=20index?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Refine the skill table description and Why section to emphasize current-branch default behavior. Document that the skill resolves the current branch against the upstream/default base branch when no explicit input is provided, and clarify that explicit change descriptions, API diffs, and compare ranges still override that default. --- README.md | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index 6b96eaf..087e801 100644 --- a/README.md +++ b/README.md @@ -95,7 +95,7 @@ npx skills add https://github.com/codebeltnet/agentic --skill dotnet-change-impa | [trunk-first-repo](skills/trunk-first-repo/SKILL.md) | Initialize a git repository following [scaled trunk-based development](https://trunkbaseddevelopment.com/#scaled-trunk-based-development). Seeds an empty `main` branch and creates a versioned feature branch (`v0.1.0/init`), enforcing a PR-first workflow where content only reaches main through peer-reviewed pull requests. | | [dotnet-strong-name-signing](skills/dotnet-strong-name-signing/SKILL.md) | Generate a strong name key (`.snk`) file for signing .NET assemblies using pure .NET cryptography — no Visual Studio Developer PowerShell or `sn.exe` required. Works in any terminal. Defaults to 1024-bit RSA (matching `sn.exe`), with 2048 and 4096 available as options. | | [git-remote-release](skills/git-remote-release/SKILL.md) | Generate GitHub release notes by summarizing all commits and pull requests between two Git tags or branches in a remote GitHub repository. Accepts a compare URL or separate owner/repo, previous ref, and current ref values; falls back to comparing the current branch against the upstream default branch when no input is provided. Produces a human-friendly `## What's Changed` summary with optional GitHub alert blocks, a `Sources:` section preserving PR and commit references, and a full changelog compare link. | -| [dotnet-change-impact](skills/dotnet-change-impact/SKILL.md) | Classify a proposed .NET library or NuGet package change and recommend the correct release bump — `Major`, `Minor`, or `Patch` — for both Semantic Versioning (`MAJOR.MINOR.PATCH`) and .NET assembly/file versioning (`Major.Minor.Build.Revision`), grounded in Microsoft's official .NET compatibility rules. Outputs exactly one word in deterministic mode when the change is clear, or a structured behavioral/binary/source/design-time/backwards compatibility analysis when the change is ambiguous, mixed, depends on public-vs-internal scope, or the user asks "why". Conservative by design so breaking changes never slip out as a patch or minor, without inflating internal-only refactors. | +| [dotnet-change-impact](skills/dotnet-change-impact/SKILL.md) | Classify .NET library or NuGet package changes and recommend the correct release bump — `Major`, `Minor`, or `Patch` — for both Semantic Versioning (`MAJOR.MINOR.PATCH`) and .NET assembly/file versioning (`Major.Minor.Build.Revision`), grounded in Microsoft's official .NET compatibility rules. Uses the current Git branch by default when no explicit change details or compare range are provided, resolving it against the upstream/default base branch with local read-only git state. Outputs exactly one word in deterministic mode when the change is clear, or a structured behavioral/binary/source/design-time/backwards compatibility analysis when the change is ambiguous, mixed, depends on public-vs-internal scope, or the user asks "why". | ### Copyable Install Commands @@ -508,9 +508,10 @@ Writing release notes is tedious. Raw commit logs are too noisy, PR titles often Picking the wrong version number is one of the easiest ways to break downstream consumers. A "bug fix" that quietly changes exception behavior, an "innocent" new overload that makes existing calls ambiguous, or a dependency bump that drops a target framework — any of these can be a breaking change shipped as a patch. Conversely, teams sometimes panic and burn a major version on a purely internal refactor. **dotnet-change-impact** brings Microsoft's official .NET compatibility model to that decision. -**dotnet-change-impact** reads a description of one or more proposed changes and recommends `Major`, `Minor`, or `Patch` for both SemVer and .NET `Major.Minor.Build.Revision` versioning. +**dotnet-change-impact** reads the current Git branch by default, comparing it against the upstream/default base branch with local read-only git state, and recommends `Major`, `Minor`, or `Patch` for both SemVer and .NET `Major.Minor.Build.Revision` versioning. Explicit change descriptions, API diffs, PR summaries, and compare ranges still override the default branch resolution. - **Two-mode output** — emits exactly one word (`Major`, `Minor`, or `Patch`) when the change is unambiguous, so it drops straight into a pipeline, or a structured analysis when the call is genuinely close, +- **Current-branch default** — when no explicit input is supplied, resolves the current branch against the upstream/default base branch, collects commits plus the net diff, and classifies that branch instead of asking for change details first, - **Grounded in Microsoft guidance** — decisions follow the official [library change rules](https://learn.microsoft.com/en-us/dotnet/core/compatibility/library-change-rules) and [compatibility categories](https://learn.microsoft.com/en-us/dotnet/core/compatibility/categories), - **Five-category compatibility lens** — behavioral, binary, source, design-time, and backwards compatibility are evaluated explicitly, - **Conservative by default** — a change that might break existing consumers is treated as breaking, so accidental breaking releases don't ship as a patch or minor, From 586bb0ef793510a51f834d0ca02c250caa6ff351 Mon Sep 17 00:00:00 2001 From: "aicia[bot]" Date: Mon, 8 Jun 2026 01:57:04 +0200 Subject: [PATCH 5/9] =?UTF-8?q?=E2=99=BB=EF=B8=8F=20refactor=20dotnet-chan?= =?UTF-8?q?ge-impact=20instructions=20and=20evals=20structure?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Reorganize and streamline SKILL.md for clarity, consolidating the input handling sections and refining the decision flow. Simplify evals.json test cases, reducing redundancy and improving focus. Maintain all core compatibility rules and guidance while improving readability. --- skills/dotnet-change-impact/SKILL.md | 149 ++++++++----------- skills/dotnet-change-impact/evals/evals.json | 94 ++++++------ 2 files changed, 109 insertions(+), 134 deletions(-) diff --git a/skills/dotnet-change-impact/SKILL.md b/skills/dotnet-change-impact/SKILL.md index f271c93..c4e572f 100644 --- a/skills/dotnet-change-impact/SKILL.md +++ b/skills/dotnet-change-impact/SKILL.md @@ -1,7 +1,7 @@ --- name: dotnet-change-impact description: > - Classifies .NET library or NuGet package changes and recommends the correct release bump: Major, Minor, or Patch. Applies both Semantic Versioning (MAJOR.MINOR.PATCH) and .NET assembly/file versioning (Major.Minor.Build.Revision), grounded in Microsoft’s official .NET library compatibility rules. Use when evaluating the current branch, breaking changes, API diffs, public API changes, dependency updates, TFM/platform support, interface or enum changes, overloads, analyzers, source generators, or binary/source/behavioral/design-time/backwards compatibility. When no explicit change details or compare range are provided, inspects the current Git branch and compares it against the upstream default branch automatically. Outputs only Major, Minor, or Patch when clear; otherwise provides structured compatibility reasoning. + Classifies .NET library or NuGet package changes and recommends the correct release bump: Major, Minor, or Patch. Applies both Semantic Versioning (MAJOR.MINOR.PATCH) and .NET assembly/file versioning (Major.Minor.Build.Revision), grounded in Microsoft’s official .NET library compatibility rules. Use when evaluating the current branch, breaking changes, API diffs, public API changes, dependency updates, TFM/platform support, interface or enum changes, overloads, analyzers, source generators, or binary/source/behavioral/design-time/backwards compatibility. When no explicit change details or compare range are provided, inspects the current Git branch and compares it against the upstream default branch automatically. Always returns structured compatibility reasoning with the recommendation. --- # .NET Change Impact @@ -119,67 +119,33 @@ git diff --find-renames {resolvedBase}...HEAD Use local Git state only for default resolution unless the user explicitly asks to refresh remote state. Do not fetch, pull, push, or mutate repository state as part of this skill. -## Critical: choose the output mode first +## Critical: include reasoning every time -Before answering, decide which mode applies. This choice is the most important behavior of the -skill, because the two modes look completely different to the user. - -### Deterministic mode - -Use this when the change is clear and unambiguous and a single bump obviously applies. Output -**exactly one** of the following words and **nothing else** — no markdown, no preamble, no -explanation, no trailing punctuation: - -```text -Major -``` - -```text -Minor -``` - -```text -Patch -``` - -The value of deterministic mode is that it can be dropped straight into a release pipeline, -a commit, or a script. Any extra prose defeats that purpose, so resist the urge to justify a -clear answer. - -### Explanation mode - -Use this when the answer is genuinely not clear-cut. Switch to explanation mode whenever any -of these is true: - -- The user asks for an explanation or asks "why". -- The input is ambiguous, incomplete, or mixed (several unrelated changes at once). -- More than one category is plausible and the deciding fact is missing. -- The decision depends on whether an API is **public or internal**. -- The decision depends on **consumer reliance**, or on documented vs. undocumented behavior. -- The decision depends on whether downstream projects treat **warnings as errors**. -- The user appears to be steering toward a lower bump than the change warrants. - -In explanation mode, do not collapse to a bare word. Surface the trade-off so the developer -can make an informed, deliberate call. Use the template in **Explanation output format** below. - -When in genuine doubt about which mode applies, prefer explanation mode. A bare word that hides -a real compatibility risk is worse than a short, honest analysis. +Always return a structured answer with the recommendation and reasoning. Do not collapse clear +decisions to a bare one-word `Major`, `Minor`, or `Patch` response. The reasoning is part of the +value of this skill, especially for branch-level analysis where the user needs to trust why the +bump follows from the diff. + +Use the template in **Output format** below for every answer. Keep the answer concise when the +decision is simple, but still explain the compatibility impact and the deciding facts. + +When the answer is ambiguous, incomplete, or depends on a missing fact, still provide the best +current recommendation and make the missing fact explicit in **Deterministic decision**. ## Internal analysis process -Run this analysis internally for every request, regardless of which mode you output. Do **not** -print this checklist when deterministic output is possible — it is reasoning scaffolding, not -part of the answer. +Run this analysis internally for every request, regardless of which mode you output. Do **not** +print this checklist verbatim — it is reasoning scaffolding, not the answer format. 1. Identify all public contract changes (types, members, signatures, accessibility, contracts). 2. Identify all observable behavior changes (return values, exceptions, ordering, serialization). 3. Identify all source compatibility risks (would existing consumer code still compile?). 4. Identify all binary compatibility risks (would existing compiled consumers still load/run?). 5. Identify all design-time compatibility risks (analyzers, generators, build, tooling, restore). -6. Determine whether existing consumers remain backwards compatible end to end. -7. Determine the highest required bump across every change present. -8. If the result is clear, produce deterministic output. -9. If the result is ambiguous or an explanation was requested, produce explanatory output. +6. Determine whether existing consumers remain backwards compatible end to end. +7. Determine the highest required bump across every change present. +8. Produce the structured output with recommendation, compatibility impact, reasoning, and the + deterministic decision. ## Version bump rules @@ -352,19 +318,24 @@ consumer-visible behavior changes, build/design-time changes, documentation-only package/dependency changes, and platform/TFM support changes. The bump follows the most impactful real change, not the loudest commit subject. -## Explanation output format - -When explanation mode applies, use exactly this structure: - -```markdown -## Recommendation - - - -## Compatibility impact - -- Behavioral change: — -- Binary compatibility: — +## Output format + +Use exactly this structure: + +```markdown +## Recommendation + + + +## Key changes identified + + + +## Compatibility impact + +- Behavioral change: — +- Binary compatibility: — - Source compatibility: — - Design-time compatibility: — - Backwards compatibility: — @@ -374,28 +345,28 @@ When explanation mode applies, use exactly this structure: -## Deterministic decision - - -``` - -## Good output characteristics - -- Emits exactly one word in deterministic mode, with no decoration. -- Switches to the structured template the moment the decision is genuinely ambiguous or an - explanation is requested. -- Picks the highest required bump when changes are mixed. -- Grounds every breaking-change call in whether existing consumers can compile, run, and - observe equivalent behavior. -- Stays conservative on interface and behavioral risk without inflating internal-only changes. - -## Bad output characteristics - -- Adding prose, markdown, or punctuation around a clear one-word answer. -- Collapsing an ambiguous or mixed change into a bare word that hides a compatibility risk. -- Labeling a publicly observable behavior change as `Patch` just because it is "a fix". -- Calling an internal, non-observable refactor `Major`. -- Hiding a breaking change behind a Build/Revision bump. +## Deterministic decision + + +``` + +## Good output characteristics + +- Always includes reasoning, even for clear `Major`, `Minor`, or `Patch` recommendations. +- Puts the recommendation first so the answer is still easy to scan. +- Names the key changes found in the branch or input before interpreting them. +- Picks the highest required bump when changes are mixed. +- Grounds every breaking-change call in whether existing consumers can compile, run, and + observe equivalent behavior. +- Stays conservative on interface and behavioral risk without inflating internal-only changes. + +## Bad output characteristics + +- Collapsing a clear change into a bare one-word answer without explaining why. +- Collapsing an ambiguous or mixed change into a recommendation that hides a compatibility risk. +- Labeling a publicly observable behavior change as `Patch` just because it is "a fix". +- Calling an internal, non-observable refactor `Major`. +- Hiding a breaking change behind a Build/Revision bump. - Inventing compatibility guarantees or migration steps the input does not support. diff --git a/skills/dotnet-change-impact/evals/evals.json b/skills/dotnet-change-impact/evals/evals.json index 46c55ed..9794de7 100644 --- a/skills/dotnet-change-impact/evals/evals.json +++ b/skills/dotnet-change-impact/evals/evals.json @@ -4,74 +4,76 @@ { "id": 1, "prompt": "In my .NET library I removed the public method `HttpRetryHandler.Send(HttpRequestMessage)` and renamed the public property `Client.BaseUri` to `Client.BaseAddress`. Should I bump major, minor, or patch?", - "expected_output": "Deterministic single-word answer: Major.", - "expectations": [ - "Outputs exactly the single word Major with no markdown, preamble, or extra prose", - "Does not add an explanation, since the breaking removal and public rename are unambiguous", - "Treats removing a public method and renaming a public property as binary and source breaking" - ] + "expected_output": "Structured answer recommending Major with compatibility reasoning.", + "expectations": [ + "Recommends Major in the Recommendation section", + "Includes Key changes identified, Compatibility impact, Reasoning, and Deterministic decision sections", + "Treats removing a public method and renaming a public property as binary and source breaking" + ] }, { "id": 2, "prompt": "I added a brand-new public class `RetryPolicy` and a new `WithRetry(this HttpClient client, int attempts)` extension method to my NuGet package. No existing public APIs were touched. What's the version bump?", - "expected_output": "Deterministic single-word answer: Minor.", - "expectations": [ - "Outputs exactly the single word Minor with no extra text", - "Recognizes purely additive, backward-compatible public surface as Minor", - "Does not escalate to Major when nothing existing was changed or removed" - ] + "expected_output": "Structured answer recommending Minor with compatibility reasoning.", + "expectations": [ + "Recommends Minor in the Recommendation section", + "Includes concise reasoning even though the change is clear", + "Recognizes purely additive, backward-compatible public surface as Minor", + "Does not escalate to Major when nothing existing was changed or removed" + ] }, { "id": 3, "prompt": "This release only fixes a NullReferenceException inside an internal cache class (no public API or observable behavior change), updates a transitive dependency from 8.0.1 to 8.0.3, and refreshes the README. Major, minor, or patch?", - "expected_output": "Deterministic single-word answer: Patch.", - "expectations": [ - "Outputs exactly the single word Patch with no extra text", - "Treats internal-only fix, compatible patch dependency bump, and docs as non-breaking", - "Does not inflate an internal, non-observable refactor to Minor or Major" - ] + "expected_output": "Structured answer recommending Patch with compatibility reasoning.", + "expectations": [ + "Recommends Patch in the Recommendation section", + "Includes concise reasoning even though the change is clear", + "Treats internal-only fix, compatible patch dependency bump, and docs as non-breaking", + "Does not inflate an internal, non-observable refactor to Minor or Major" + ] }, { "id": 4, "prompt": "I changed `DateParser.Parse` to throw a FormatException on empty input instead of returning null. Should this be a patch? It's just a bug fix.", - "expected_output": "Explanation-mode answer: ambiguous because it depends on whether Parse is public and whether consumers rely on the null-return behavior. Should not just say Patch.", - "expectations": [ - "Switches to explanation mode instead of emitting a bare single word", - "Uses the structured template with Recommendation, Compatibility impact, Reasoning, and Deterministic decision sections", - "Flags this as a behavioral change that can be breaking even though it compiles", - "Does not accept the user's framing that a bug fix is automatically a Patch", + "expected_output": "Structured answer: ambiguous because it depends on whether Parse is public and whether consumers rely on the null-return behavior. Should not just say Patch.", + "expectations": [ + "Uses structured reasoning instead of emitting a bare single word", + "Uses the structured template with Recommendation, Compatibility impact, Reasoning, and Deterministic decision sections", + "Flags this as a behavioral change that can be breaking even though it compiles", + "Does not accept the user's framing that a bug fix is automatically a Patch", "Identifies the deciding fact: whether Parse is public and whether the old null-return behavior is relied upon or documented" ] }, { "id": 5, "prompt": "Big release: I added two new public extension methods, fixed a couple of internal bugs, AND removed a public `ILogger` overload that nobody should be using. One command answer please: major, minor, or patch?", - "expected_output": "Deterministic single-word answer: Major, because precedence picks the highest required bump and the public removal is breaking.", - "expectations": [ - "Outputs exactly the single word Major", - "Applies precedence: the breaking public removal dominates the additive and internal changes", - "Does not downgrade to Minor or Patch despite the user implying the removed overload is unused" - ] + "expected_output": "Structured answer recommending Major, because precedence picks the highest required bump and the public removal is breaking.", + "expectations": [ + "Recommends Major in the Recommendation section", + "Includes concise reasoning despite the user's request for a one-command answer", + "Applies precedence: the breaking public removal dominates the additive and internal changes", + "Does not downgrade to Minor or Patch despite the user implying the removed overload is unused" + ] }, { "id": 6, "prompt": "I added a new member `Task FlushAsync()` to my public interface `IMessageSink`. Existing implementations are out in the wild via my NuGet package. Why would this be more than a patch?", - "expected_output": "Explanation-mode answer recommending Major, explaining that adding a member to a public interface breaks existing implementers (source compatibility).", - "expectations": [ - "Switches to explanation mode because the user asked why", - "Recommends Major", - "Explains that adding a member to an existing public interface breaks existing implementers' source compilation", - "Mentions default interface members as a nuance without treating them as automatically safe", + "expected_output": "Structured answer recommending Major, explaining that adding a member to a public interface breaks existing implementers (source compatibility).", + "expectations": [ + "Recommends Major", + "Explains that adding a member to an existing public interface breaks existing implementers' source compilation", + "Mentions default interface members as a nuance without treating them as automatically safe", "Uses the structured explanation template" ] }, { "id": 7, "prompt": "I added a new enum value `LogLevel.Trace` to an existing public enum. My library serializes these values to JSON and some consumers switch over them. Patch, minor, or major?", - "expected_output": "Explanation-mode answer: usually Minor but flag the exhaustive-switch and serialization-contract risk that could make it behavioral/source-impacting.", - "expectations": [ - "Does not emit a bare one-word answer given the explicit switch and serialization caveats", - "Notes that adding an enum value is usually Minor", + "expected_output": "Structured answer: usually Minor but flag the exhaustive-switch and serialization-contract risk that could make it behavioral/source-impacting.", + "expectations": [ + "Does not emit a bare one-word answer given the explicit switch and serialization caveats", + "Notes that adding an enum value is usually Minor", "Flags exhaustive consumer switch statements and serialization contracts as escalation risks", "Uses the structured explanation template with a clear recommendation" ] @@ -79,21 +81,23 @@ { "id": 8, "prompt": "My library dropped support for net6.0 and now targets only net8.0 and net9.0. Existing consumers on net6.0 will be affected. Version bump?", - "expected_output": "Deterministic single-word answer: Major, because removing TFM/platform support is breaking for existing consumers.", - "expectations": [ - "Outputs exactly the single word Major", - "Treats removing TFM support as breaking for existing consumers", + "expected_output": "Structured answer recommending Major, because removing TFM/platform support is breaking for existing consumers.", + "expectations": [ + "Recommends Major in the Recommendation section", + "Includes concise reasoning even though the change is clear", + "Treats removing TFM support as breaking for existing consumers", "Does not classify dropped framework support as Minor or Patch" ] }, { "id": 9, "prompt": "Use dotnet-change-impact to classify the version bump for this branch.", - "expected_output": "Current-branch default-resolution behavior: inspect the local Git repository, resolve the current branch against the upstream/default base branch, collect commits and net diff, then classify those changes. Must not ask the user to provide change details first.", + "expected_output": "Current-branch default-resolution behavior: inspect the local Git repository, resolve the current branch against the upstream/default base branch, collect commits and net diff, then classify those changes with structured reasoning. Must not ask the user to provide change details first.", "expectations": [ "Follows Default Resolution Behavior when no explicit change details or compare range are provided", "Detects the current branch and resolves a base branch using local Git state, following the documented fallback order", "Collects both branch commits and net diff before classifying compatibility impact", + "Returns structured reasoning with the recommendation instead of a bare Major, Minor, or Patch", "Does not respond with a generic request for release notes, diffs, PR summaries, or bug descriptions when the current repository can be inspected", "Asks only for the missing base branch or compare range if local default resolution cannot identify one" ] From 130021200a14109320b7d7d268412c9711439e0a Mon Sep 17 00:00:00 2001 From: "aicia[bot]" Date: Mon, 8 Jun 2026 01:57:08 +0200 Subject: [PATCH 6/9] =?UTF-8?q?=F0=9F=92=AC=20refresh=20dotnet-change-impa?= =?UTF-8?q?ct=20skill=20description?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Update the skill table entry in README to reflect the reorganized instructions and simplified evals. Clarify the current-branch default behavior and ensure consistency with the refined SKILL.md. --- README.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index 087e801..6c96113 100644 --- a/README.md +++ b/README.md @@ -95,7 +95,7 @@ npx skills add https://github.com/codebeltnet/agentic --skill dotnet-change-impa | [trunk-first-repo](skills/trunk-first-repo/SKILL.md) | Initialize a git repository following [scaled trunk-based development](https://trunkbaseddevelopment.com/#scaled-trunk-based-development). Seeds an empty `main` branch and creates a versioned feature branch (`v0.1.0/init`), enforcing a PR-first workflow where content only reaches main through peer-reviewed pull requests. | | [dotnet-strong-name-signing](skills/dotnet-strong-name-signing/SKILL.md) | Generate a strong name key (`.snk`) file for signing .NET assemblies using pure .NET cryptography — no Visual Studio Developer PowerShell or `sn.exe` required. Works in any terminal. Defaults to 1024-bit RSA (matching `sn.exe`), with 2048 and 4096 available as options. | | [git-remote-release](skills/git-remote-release/SKILL.md) | Generate GitHub release notes by summarizing all commits and pull requests between two Git tags or branches in a remote GitHub repository. Accepts a compare URL or separate owner/repo, previous ref, and current ref values; falls back to comparing the current branch against the upstream default branch when no input is provided. Produces a human-friendly `## What's Changed` summary with optional GitHub alert blocks, a `Sources:` section preserving PR and commit references, and a full changelog compare link. | -| [dotnet-change-impact](skills/dotnet-change-impact/SKILL.md) | Classify .NET library or NuGet package changes and recommend the correct release bump — `Major`, `Minor`, or `Patch` — for both Semantic Versioning (`MAJOR.MINOR.PATCH`) and .NET assembly/file versioning (`Major.Minor.Build.Revision`), grounded in Microsoft's official .NET compatibility rules. Uses the current Git branch by default when no explicit change details or compare range are provided, resolving it against the upstream/default base branch with local read-only git state. Outputs exactly one word in deterministic mode when the change is clear, or a structured behavioral/binary/source/design-time/backwards compatibility analysis when the change is ambiguous, mixed, depends on public-vs-internal scope, or the user asks "why". | +| [dotnet-change-impact](skills/dotnet-change-impact/SKILL.md) | Classify .NET library or NuGet package changes and recommend the correct release bump — `Major`, `Minor`, or `Patch` — for both Semantic Versioning (`MAJOR.MINOR.PATCH`) and .NET assembly/file versioning (`Major.Minor.Build.Revision`), grounded in Microsoft's official .NET compatibility rules. Uses the current Git branch by default when no explicit change details or compare range are provided, resolving it against the upstream/default base branch with local read-only git state. Always returns structured behavioral/binary/source/design-time/backwards compatibility reasoning with the recommendation, even when the bump is clear. | ### Copyable Install Commands @@ -510,7 +510,7 @@ Picking the wrong version number is one of the easiest ways to break downstream **dotnet-change-impact** reads the current Git branch by default, comparing it against the upstream/default base branch with local read-only git state, and recommends `Major`, `Minor`, or `Patch` for both SemVer and .NET `Major.Minor.Build.Revision` versioning. Explicit change descriptions, API diffs, PR summaries, and compare ranges still override the default branch resolution. -- **Two-mode output** — emits exactly one word (`Major`, `Minor`, or `Patch`) when the change is unambiguous, so it drops straight into a pipeline, or a structured analysis when the call is genuinely close, +- **Reasoned output by default** — always puts the recommendation first, then explains the key changes, compatibility impact, reasoning, and deterministic decision so the version call is reviewable, - **Current-branch default** — when no explicit input is supplied, resolves the current branch against the upstream/default base branch, collects commits plus the net diff, and classifies that branch instead of asking for change details first, - **Grounded in Microsoft guidance** — decisions follow the official [library change rules](https://learn.microsoft.com/en-us/dotnet/core/compatibility/library-change-rules) and [compatibility categories](https://learn.microsoft.com/en-us/dotnet/core/compatibility/categories), - **Five-category compatibility lens** — behavioral, binary, source, design-time, and backwards compatibility are evaluated explicitly, From 9eb8a265c5ebec08f6d365a76f3b057beddfd3b5 Mon Sep 17 00:00:00 2001 From: "aicia[bot]" Date: Mon, 8 Jun 2026 02:03:45 +0200 Subject: [PATCH 7/9] =?UTF-8?q?=F0=9F=92=AC=20update=20changelog=20for=200?= =?UTF-8?q?.5.0=20release=20with=20new=20git-remote-release=20skill?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- CHANGELOG.md | 55 ++++++++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 53 insertions(+), 2 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 79b279e..7ed6892 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -6,6 +6,54 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), ## [Unreleased] +## [0.5.0] - 2026-06-07 + +This is a minor release introducing the `git-remote-release` skill for generating GitHub release notes by summarizing commits and pull requests between git tags or branches. This complements the existing changelog and release-notes workflow by providing a GitHub-specific release entry point. + +### Added + +- `git-remote-release` skill that reads a commit range or github.com compare URL, summarizes all commits and pull requests between two git references, and generates GitHub release notes with proper markdown formatting, +- `FORMS.md` for `git-remote-release` with structured input collection for branch/tag range specification, +- Hero image asset for `git-remote-release`, +- Evals coverage for `git-remote-release` release notes generation. + +### Changed + +- Expanded README with `git-remote-release` installation snippet and capability showcase documenting release notes generation from commits, PRs, and branch comparisons. + +## [0.4.6] - 2026-06-07 + +This is a patch release focused on strengthening scaffolding templates with safeguards and coverage guidance, plus clarifying the author-neutral scope of `git-visual-squash-summary` to prevent stale same-named tracking branches from hiding work. + +### Added + +- Safeguards and coverage guidance in `dotnet-new-app-slnx` and `dotnet-new-lib-slnx` shared assets (`AGENTS.md` and `.github/copilot-instructions.md`) documenting bot workspace management, eval isolation discipline, and git identity rules, +- Eval coverage for `git-visual-squash-summary` documenting author-neutral scope and base-branch resolution behavior. + +### Changed + +- Enhanced `git-visual-squash-summary` SKILL.md guidance to clarify author-neutral scope and to explicitly document how the skill compares against repository base branches rather than same-named tracking remotes, preventing stale tracking copies from masking real work, +- Updated `git-visual-squash-summary` shared documentation in scaffold templates to reflect author-neutral behavior and base-branch-first resolution. + +## [0.4.5] - 2026-05-31 + +This is a patch release focused on improving `git-repo-digest` documentation link extraction and validation logic, expanding eval coverage, and establishing explicit git operations safeguards policy for agent-driven repositories. The skill now validates documentation URLs with HTTP HEAD requests before accepting them, provides fallback chains across multiple documentation sources, and fails fast when no valid URL is found. + +### Added + +- Enhanced `git-repo-digest` documentation URL resolution with HTTP validation, probing multiple fallback sources (package URLs, `.docfx/docfx.json` hints, `README.md` links) and requiring at least one `200 OK` response before generating digest prose, +- Evals 43–45 covering HTTP-validated documentation URL fallback chains, convenience package documentation linking, and edge cases, +- Git Operations Safeguards section in `AGENTS.md` establishing mandatory approval gates for agent-driven commits and remote operations, explicitly forbidding automatic pushes, pulls, or fetches without user instruction, +- Additional safeguards context in README and AGENTS.md clarifying that automatic commits pollute history and unexpected remote operations risk data loss. + +### Changed + +- Refined `git-repo-digest` SKILL.md guidance to preserve generated `title` from repository-owned `` metadata instead of replacing with invented prose, and to treat generated documentation links as validated HTTP URLs, +- Enhanced `git-repo-digest` `digest.cs` with robust HTTP client setup, 10-second timeout for documentation validation, improved error handling for failed URL validation requests, and clear retry guidance when candidates fail, +- Updated manifest documentation for `frontmatterHints` to clarify that documentation entries are validated HTTP URLs and that overview `title` comes from repository metadata, +- Expanded eval contracts and test case documentation to cover HTTP validation failures, timeout behavior, and fallback chain exhaustion, +- Updated README.md guidance to highlight HTTP-validated documentation URL resolution and documented git operations safeguards. + ## [0.4.4] - 2026-05-18 This is a minor release strengthening `git-repo-digest` with HTTP-validated documentation URL resolution and repository-owned product title discovery, plus clarifying `git-visual-squash-summary` base branch resolution behavior to prevent stale same-named tracking branches from hiding work. The `git-repo-digest` runner now resolves documentation hosts from package URLs and project configuration, validates candidate documentation URLs with HTTP HEAD requests, falls back across multiple sources (root `PackageProjectUrl`, `.docfx/docfx.json`, README `## Documentation` links), and fails fast when no candidate returns `200 OK`. Repository titles for `result/Index.md` are sourced from a root `Directory.Build.props` `` value, with fallback to the highest-referenced top-level packable `.csproj` `` when the root value is absent. The `git-visual-squash-summary` skill now explicitly avoids using a same-named tracking remote such as `origin/` as a squash base; instead it resolves against the repository's actual base branch such as `origin/main`, `origin/master`, `main`, or `master` before declaring there is nothing to summarize. @@ -275,8 +323,11 @@ This is a minor release that introduces two complementary git workflow skills, e - Improved scaffold fidelity with hidden `.bot` asset preservation, explicit UTF-8 and BOM handling, and checks aimed at preventing mojibake or incomplete generated output. -[Unreleased]: https://github.com/codebeltnet/agentic/compare/v0.4.4...HEAD -[0.4.5]: https://github.com/codebeltnet/agentic/compare/v0.4.3...v0.4.4 +[Unreleased]: https://github.com/codebeltnet/agentic/compare/v0.5.0...HEAD +[0.5.0]: https://github.com/codebeltnet/agentic/compare/v0.4.6...v0.5.0 +[0.4.6]: https://github.com/codebeltnet/agentic/compare/v0.4.5...v0.4.6 +[0.4.5]: https://github.com/codebeltnet/agentic/compare/v0.4.4...v0.4.5 +[0.4.4]: https://github.com/codebeltnet/agentic/compare/v0.4.3...v0.4.4 [0.4.3]: https://github.com/codebeltnet/agentic/compare/v0.4.2...v0.4.3 [0.4.2]: https://github.com/codebeltnet/agentic/compare/v0.4.1...v0.4.2 [0.4.1]: https://github.com/codebeltnet/agentic/compare/v0.4.0...v0.4.1 From 29398be3ebe18a7cc2c334b264642c19ce6a6be3 Mon Sep 17 00:00:00 2001 From: "aicia[bot]" Date: Mon, 8 Jun 2026 02:14:32 +0200 Subject: [PATCH 8/9] =?UTF-8?q?=F0=9F=92=AC=20update=20changelog=20for=200?= =?UTF-8?q?.6.0=20release=20with=20dotnet-change-impact=20skill?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- CHANGELOG.md | 19 ++++++++++++++++++- 1 file changed, 18 insertions(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 7ed6892..faec5aa 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -6,6 +6,22 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), ## [Unreleased] +## [0.6.0] - 2026-06-08 + +This is a minor release introducing the `dotnet-change-impact` skill for classifying .NET library and NuGet package changes against Microsoft's official compatibility rules. The skill automatically resolves the current branch against the upstream default branch, compares commits and diffs, and recommends the correct SemVer release bump (Major, Minor, or Patch) along with structured compatibility reasoning. + +### Added + +- `dotnet-change-impact` skill that classifies .NET library changes and recommends version bumps according to Microsoft's official .NET library compatibility model, supporting breaking changes, API diffs, public API changes, dependency updates, TFM and platform support changes, interface and enum modifications, overloads, analyzers, and source generators, +- Automatic default-branch resolution in `dotnet-change-impact` when no explicit change details or compare range are provided; the skill inspects the current Git branch and compares against the upstream default branch, with fallback to `main` or `master`, +- Comprehensive compatibility-categories reference documentation in `references/compatibility-categories.md` covering Major (breaking changes, removals, contract modifications), Minor (new capabilities without breaking changes), and Patch (fixes, maintenance, non-breaking refinement) classifications, +- Per-skill evals coverage for `dotnet-change-impact` including current-branch detection, breaking-change scenarios, API compatibility assessments, dependency updates, and SemVer classification validation, +- `dotnet-change-impact` registered in README skill index with install snippet and detailed "Why dotnet-change-impact?" section explaining Microsoft compatibility grounding and key capabilities. + +### Changed + +- Enhanced README with `dotnet-change-impact` installation guidance and capability showcase, including examples of breaking changes, API diffs, and compatibility assessment workflows. + ## [0.5.0] - 2026-06-07 This is a minor release introducing the `git-remote-release` skill for generating GitHub release notes by summarizing commits and pull requests between git tags or branches. This complements the existing changelog and release-notes workflow by providing a GitHub-specific release entry point. @@ -323,7 +339,8 @@ This is a minor release that introduces two complementary git workflow skills, e - Improved scaffold fidelity with hidden `.bot` asset preservation, explicit UTF-8 and BOM handling, and checks aimed at preventing mojibake or incomplete generated output. -[Unreleased]: https://github.com/codebeltnet/agentic/compare/v0.5.0...HEAD +[Unreleased]: https://github.com/codebeltnet/agentic/compare/v0.6.0...HEAD +[0.6.0]: https://github.com/codebeltnet/agentic/compare/v0.5.0...v0.6.0 [0.5.0]: https://github.com/codebeltnet/agentic/compare/v0.4.6...v0.5.0 [0.4.6]: https://github.com/codebeltnet/agentic/compare/v0.4.5...v0.4.6 [0.4.5]: https://github.com/codebeltnet/agentic/compare/v0.4.4...v0.4.5 From c8bc320bcb77343678ef27481e40fe9e20d76b46 Mon Sep 17 00:00:00 2001 From: "aicia[bot]" Date: Mon, 8 Jun 2026 02:43:32 +0200 Subject: [PATCH 9/9] =?UTF-8?q?=F0=9F=92=AC=20polish=20dotnet-change-impac?= =?UTF-8?q?t=20docs=20and=20add=20hero=20asset?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Improve SKILL.md readability by removing artificial line breaks, add hero image reference, include assets/hero.jpg, and update CHANGELOG to reflect these refinements. --- CHANGELOG.md | 6 +- skills/dotnet-change-impact/SKILL.md | 346 ++++++++++---------- skills/dotnet-change-impact/assets/hero.jpg | Bin 0 -> 100007 bytes 3 files changed, 174 insertions(+), 178 deletions(-) create mode 100644 skills/dotnet-change-impact/assets/hero.jpg diff --git a/CHANGELOG.md b/CHANGELOG.md index faec5aa..57cfd8e 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -16,11 +16,13 @@ This is a minor release introducing the `dotnet-change-impact` skill for classif - Automatic default-branch resolution in `dotnet-change-impact` when no explicit change details or compare range are provided; the skill inspects the current Git branch and compares against the upstream default branch, with fallback to `main` or `master`, - Comprehensive compatibility-categories reference documentation in `references/compatibility-categories.md` covering Major (breaking changes, removals, contract modifications), Minor (new capabilities without breaking changes), and Patch (fixes, maintenance, non-breaking refinement) classifications, - Per-skill evals coverage for `dotnet-change-impact` including current-branch detection, breaking-change scenarios, API compatibility assessments, dependency updates, and SemVer classification validation, -- `dotnet-change-impact` registered in README skill index with install snippet and detailed "Why dotnet-change-impact?" section explaining Microsoft compatibility grounding and key capabilities. +- `dotnet-change-impact` registered in README skill index with install snippet and detailed "Why dotnet-change-impact?" section explaining Microsoft compatibility grounding and key capabilities, +- Hero image asset for `dotnet-change-impact`. ### Changed -- Enhanced README with `dotnet-change-impact` installation guidance and capability showcase, including examples of breaking changes, API diffs, and compatibility assessment workflows. +- Enhanced README with `dotnet-change-impact` installation guidance and capability showcase, including examples of breaking changes, API diffs, and compatibility assessment workflows, +- Improved prose readability in `dotnet-change-impact` SKILL.md by removing artificial line breaks to enhance natural reading flow. ## [0.5.0] - 2026-06-07 diff --git a/skills/dotnet-change-impact/SKILL.md b/skills/dotnet-change-impact/SKILL.md index c4e572f..47e5b64 100644 --- a/skills/dotnet-change-impact/SKILL.md +++ b/skills/dotnet-change-impact/SKILL.md @@ -1,151 +1,150 @@ --- name: dotnet-change-impact -description: > - Classifies .NET library or NuGet package changes and recommends the correct release bump: Major, Minor, or Patch. Applies both Semantic Versioning (MAJOR.MINOR.PATCH) and .NET assembly/file versioning (Major.Minor.Build.Revision), grounded in Microsoft’s official .NET library compatibility rules. Use when evaluating the current branch, breaking changes, API diffs, public API changes, dependency updates, TFM/platform support, interface or enum changes, overloads, analyzers, source generators, or binary/source/behavioral/design-time/backwards compatibility. When no explicit change details or compare range are provided, inspects the current Git branch and compares it against the upstream default branch automatically. Always returns structured compatibility reasoning with the recommendation. ---- +description: > + Classifies .NET library or NuGet package changes and recommends the correct release bump: Major, Minor, or Patch. Applies both Semantic Versioning (MAJOR.MINOR.PATCH) and .NET assembly/file versioning (Major.Minor.Build.Revision), grounded in Microsoft’s official .NET library compatibility rules. Use when evaluating the current branch, breaking changes, API diffs, public API changes, dependency updates, TFM/platform support, interface or enum changes, overloads, analyzers, source generators, or binary/source/behavioral/design-time/backwards compatibility. When no explicit change details or compare range are provided, inspects the current Git branch and compares it against the upstream default branch automatically. Always returns structured compatibility reasoning with the recommendation. +--- # .NET Change Impact -Classify a proposed change to a .NET library or NuGet package and recommend the correct -release bump. This skill exists to stop accidental breaking releases from being shipped as -a patch or minor, while staying practical enough not to label every internal refactor as -breaking. +![.NET Change Impact](assets/hero.jpg) + +Classify a proposed change to a .NET library or NuGet package and recommend the correct release bump. This skill exists to stop accidental breaking releases from being shipped as a patch or minor, while staying practical enough not to label every internal refactor as breaking. It answers one question: > Given these changes, should I bump **Major**, **Minor**, or **Patch**? -The authority for every decision is Microsoft's official .NET compatibility guidance: +The authority for every decision is Microsoft's official .NET compatibility guidance: - https://learn.microsoft.com/en-us/dotnet/core/compatibility/library-change-rules - https://learn.microsoft.com/en-us/dotnet/core/compatibility/categories -Treat those two sources as normative. When the deep category definitions or the long tail of -special cases matter, read `references/compatibility-categories.md`. - -## Input - -The skill accepts input in three ways, checked in this order: - -**1. Explicit change details:** - -When the user provides release notes, a PR summary, an API diff, a git diff, a changelog entry, -dependency update details, a bug-fix description, or a stated release intent, classify those -provided changes directly. - -**2. Explicit compare range:** - -When the user provides a base ref, current ref, compare URL, branch name, tag range, or commit -range, inspect that range and classify the changes found there. - -**3. Default resolution (no input provided):** - -When the user does not provide explicit change details or a compare range, operate on the -current Git working repository. See **Default Resolution Behavior** below. - -If required information is missing and cannot be inferred or resolved, ask only for the missing -fact. Do not ask the user to restate the whole change set when the current repository or an -explicit compare range can be inspected. - -## Default Resolution Behavior - -If the user does not provide explicit change details, a compare URL, branch name, tag range, or -commit range, the skill must operate on the current Git working repository. - -In that case, the skill must: - -1. Detect the current branch. -2. Detect the upstream remote for the repository. -3. Detect the upstream repository's default branch — usually `main`, but do not assume `main` if - the remote default branch can be resolved. -4. Compare the current branch against the upstream remote default branch. -5. Include all commits on the current branch that are not present in the upstream remote default - branch. -6. Include the net diff for the comparison range, because compatibility impact often depends on - files changed, signatures, project metadata, target frameworks, package references, generated - assets, and build props/targets. -7. Classify the release bump from the collected branch changes using the normal compatibility - rules. - -The default comparison should be conceptually equivalent to: - -```text -upstream/default-branch...current-branch -``` - -For example, if the current branch is `feature/change-impact` and the upstream default branch is -`main`, the comparison should be treated as: - -```text -upstream/main...feature/change-impact -``` - -If the repository uses `origin` as the upstream remote, use: - -```text -origin/main...current-branch -``` - -If the repository has both `origin` and `upstream`, prefer the remote that represents the -canonical source repository. In fork-based workflows, this is usually `upstream`. In -single-repository workflows, this is usually `origin`. - -The skill must not silently assume the wrong base branch. If the default branch cannot be -resolved, fall back in this order: - -1. `origin/HEAD` -2. `upstream/HEAD` -3. `origin/main` -4. `origin/master` -5. `upstream/main` -6. `upstream/master` - -If none of these can be resolved, ask the user to provide the base branch or compare range. - -Useful read-only commands for default resolution: - -```bash -git rev-parse --abbrev-ref HEAD -git remote -git symbolic-ref refs/remotes/origin/HEAD --short -git symbolic-ref refs/remotes/upstream/HEAD --short -git merge-base HEAD {resolvedBase} -git log --oneline {resolvedBase}..HEAD -git log --format="%H%x09%an%x09%ae%x09%s%x09%b" {resolvedBase}..HEAD -git diff --name-status {resolvedBase}...HEAD -git diff --find-renames {resolvedBase}...HEAD -``` - -Use local Git state only for default resolution unless the user explicitly asks to refresh remote -state. Do not fetch, pull, push, or mutate repository state as part of this skill. - -## Critical: include reasoning every time - -Always return a structured answer with the recommendation and reasoning. Do not collapse clear -decisions to a bare one-word `Major`, `Minor`, or `Patch` response. The reasoning is part of the -value of this skill, especially for branch-level analysis where the user needs to trust why the -bump follows from the diff. - -Use the template in **Output format** below for every answer. Keep the answer concise when the -decision is simple, but still explain the compatibility impact and the deciding facts. - -When the answer is ambiguous, incomplete, or depends on a missing fact, still provide the best -current recommendation and make the missing fact explicit in **Deterministic decision**. +Treat those two sources as normative. When the deep category definitions or the long tail of +special cases matter, read `references/compatibility-categories.md`. + +## Input + +The skill accepts input in three ways, checked in this order: + +**1. Explicit change details:** + +When the user provides release notes, a PR summary, an API diff, a git diff, a changelog entry, +dependency update details, a bug-fix description, or a stated release intent, classify those +provided changes directly. + +**2. Explicit compare range:** + +When the user provides a base ref, current ref, compare URL, branch name, tag range, or commit +range, inspect that range and classify the changes found there. + +**3. Default resolution (no input provided):** + +When the user does not provide explicit change details or a compare range, operate on the +current Git working repository. See **Default Resolution Behavior** below. + +If required information is missing and cannot be inferred or resolved, ask only for the missing +fact. Do not ask the user to restate the whole change set when the current repository or an +explicit compare range can be inspected. + +## Default Resolution Behavior + +If the user does not provide explicit change details, a compare URL, branch name, tag range, or +commit range, the skill must operate on the current Git working repository. + +In that case, the skill must: + +1. Detect the current branch. +2. Detect the upstream remote for the repository. +3. Detect the upstream repository's default branch — usually `main`, but do not assume `main` if + the remote default branch can be resolved. +4. Compare the current branch against the upstream remote default branch. +5. Include all commits on the current branch that are not present in the upstream remote default + branch. +6. Include the net diff for the comparison range, because compatibility impact often depends on + files changed, signatures, project metadata, target frameworks, package references, generated + assets, and build props/targets. +7. Classify the release bump from the collected branch changes using the normal compatibility + rules. + +The default comparison should be conceptually equivalent to: + +```text +upstream/default-branch...current-branch +``` + +For example, if the current branch is `feature/change-impact` and the upstream default branch is +`main`, the comparison should be treated as: + +```text +upstream/main...feature/change-impact +``` + +If the repository uses `origin` as the upstream remote, use: + +```text +origin/main...current-branch +``` + +If the repository has both `origin` and `upstream`, prefer the remote that represents the +canonical source repository. In fork-based workflows, this is usually `upstream`. In +single-repository workflows, this is usually `origin`. + +The skill must not silently assume the wrong base branch. If the default branch cannot be +resolved, fall back in this order: + +1. `origin/HEAD` +2. `upstream/HEAD` +3. `origin/main` +4. `origin/master` +5. `upstream/main` +6. `upstream/master` + +If none of these can be resolved, ask the user to provide the base branch or compare range. + +Useful read-only commands for default resolution: + +```bash +git rev-parse --abbrev-ref HEAD +git remote +git symbolic-ref refs/remotes/origin/HEAD --short +git symbolic-ref refs/remotes/upstream/HEAD --short +git merge-base HEAD {resolvedBase} +git log --oneline {resolvedBase}..HEAD +git log --format="%H%x09%an%x09%ae%x09%s%x09%b" {resolvedBase}..HEAD +git diff --name-status {resolvedBase}...HEAD +git diff --find-renames {resolvedBase}...HEAD +``` + +Use local Git state only for default resolution unless the user explicitly asks to refresh remote +state. Do not fetch, pull, push, or mutate repository state as part of this skill. + +## Critical: include reasoning every time + +Always return a structured answer with the recommendation and reasoning. Do not collapse clear +decisions to a bare one-word `Major`, `Minor`, or `Patch` response. The reasoning is part of the +value of this skill, especially for branch-level analysis where the user needs to trust why the +bump follows from the diff. + +Use the template in **Output format** below for every answer. Keep the answer concise when the +decision is simple, but still explain the compatibility impact and the deciding facts. + +When the answer is ambiguous, incomplete, or depends on a missing fact, still provide the best +current recommendation and make the missing fact explicit in **Deterministic decision**. ## Internal analysis process -Run this analysis internally for every request, regardless of which mode you output. Do **not** -print this checklist verbatim — it is reasoning scaffolding, not the answer format. +Run this analysis internally for every request, regardless of which mode you output. Do **not** +print this checklist verbatim — it is reasoning scaffolding, not the answer format. 1. Identify all public contract changes (types, members, signatures, accessibility, contracts). 2. Identify all observable behavior changes (return values, exceptions, ordering, serialization). 3. Identify all source compatibility risks (would existing consumer code still compile?). 4. Identify all binary compatibility risks (would existing compiled consumers still load/run?). 5. Identify all design-time compatibility risks (analyzers, generators, build, tooling, restore). -6. Determine whether existing consumers remain backwards compatible end to end. -7. Determine the highest required bump across every change present. -8. Produce the structured output with recommendation, compatibility impact, reasoning, and the - deterministic decision. +6. Determine whether existing consumers remain backwards compatible end to end. +7. Determine the highest required bump across every change present. +8. Produce the structured output with recommendation, compatibility impact, reasoning, and the + deterministic decision. ## Version bump rules @@ -309,33 +308,28 @@ These recur often enough to call out directly. The full catalog is in - `Build` and `Revision` are CI/build metadata. Never use them to hide a breaking change, and do not use them as a substitute for a SemVer Patch when NuGet package versioning is involved. -## Input interpretation - -Input may arrive as release notes, git commits, PR summaries, API diffs, changelog entries, -dependency updates, bug-fix descriptions, a stated release intent, or the default current-branch -comparison. Distinguish carefully between: public API changes, internal implementation changes, -consumer-visible behavior changes, build/design-time changes, documentation-only changes, -package/dependency changes, and platform/TFM support changes. The bump follows the most -impactful real change, not the loudest commit subject. - -## Output format - -Use exactly this structure: - -```markdown -## Recommendation - - - -## Key changes identified - - - -## Compatibility impact - -- Behavioral change: — -- Binary compatibility: — +## Input interpretation + +Input may arrive as release notes, git commits, PR summaries, API diffs, changelog entries, dependency updates, bug-fix descriptions, a stated release intent, or the default current-branch comparison. Distinguish carefully between: public API changes, internal implementation changes, consumer-visible behavior changes, build/design-time changes, documentation-only changes, package/dependency changes, and platform/TFM support changes. The bump follows the most impactful real change, not the loudest commit subject. + +## Output format + +Use exactly this structure: + +```markdown +## Recommendation + + + +## Key changes identified + + + +## Compatibility impact + +- Behavioral change: — +- Binary compatibility: — - Source compatibility: — - Design-time compatibility: — - Backwards compatibility: — @@ -345,28 +339,28 @@ there is truly no concrete change to list.> -## Deterministic decision - - -``` - -## Good output characteristics - -- Always includes reasoning, even for clear `Major`, `Minor`, or `Patch` recommendations. -- Puts the recommendation first so the answer is still easy to scan. -- Names the key changes found in the branch or input before interpreting them. -- Picks the highest required bump when changes are mixed. -- Grounds every breaking-change call in whether existing consumers can compile, run, and - observe equivalent behavior. -- Stays conservative on interface and behavioral risk without inflating internal-only changes. - -## Bad output characteristics - -- Collapsing a clear change into a bare one-word answer without explaining why. -- Collapsing an ambiguous or mixed change into a recommendation that hides a compatibility risk. -- Labeling a publicly observable behavior change as `Patch` just because it is "a fix". -- Calling an internal, non-observable refactor `Major`. -- Hiding a breaking change behind a Build/Revision bump. +## Deterministic decision + + +``` + +## Good output characteristics + +- Always includes reasoning, even for clear `Major`, `Minor`, or `Patch` recommendations. +- Puts the recommendation first so the answer is still easy to scan. +- Names the key changes found in the branch or input before interpreting them. +- Picks the highest required bump when changes are mixed. +- Grounds every breaking-change call in whether existing consumers can compile, run, and + observe equivalent behavior. +- Stays conservative on interface and behavioral risk without inflating internal-only changes. + +## Bad output characteristics + +- Collapsing a clear change into a bare one-word answer without explaining why. +- Collapsing an ambiguous or mixed change into a recommendation that hides a compatibility risk. +- Labeling a publicly observable behavior change as `Patch` just because it is "a fix". +- Calling an internal, non-observable refactor `Major`. +- Hiding a breaking change behind a Build/Revision bump. - Inventing compatibility guarantees or migration steps the input does not support. diff --git a/skills/dotnet-change-impact/assets/hero.jpg b/skills/dotnet-change-impact/assets/hero.jpg new file mode 100644 index 0000000000000000000000000000000000000000..78e7ba60715805d180f7858174b584905fab566a GIT binary patch literal 100007 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

@@Uep5zF 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 z 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 DGnl9< literal 0 HcmV?d00001