werkcrappit/CHANGELOG.md

# Changelog

Up to 0.26.14, every pull request added its version here, newest first.
Since then, each PR document holds its release notes, and `./gradlew changelog` writes the full changelog
into `build/changelog/CHANGELOG.md`: the newer versions, then this file.

## 0.26.14

- Internal: the README links the latest code city, structure page and matrix of the demo in werkprobe,
  and werkcrappit's own latest code city.
  No change to the plugins.

## 0.26.13

- Internal: `docs/agentic-workflow.md` is the master copy of werkregie again.
  No change to the plugins.

## 0.26.12

- `structure.html` puts 40 pixels between the lines of a wrapped level and shifts every second line by half a step,
  so the edges into the lower lines stay visible.

## 0.26.11

- Internal: werkrevisor's writing rules skip the generated example reports.
  No change to the plugins.

## 0.26.10

- `docs/examples` holds example reports, `mutation-crap.json` and `mutation-crap.md`, with every state a method can have.
  A test keeps them equal to what the writers write.
  No change to the plugins.

## 0.26.9

- Internal: `docs/final-report.md` reports the Java MVP as section 8.5 of the specification asks.
  The README lists the runtime dependencies and their licenses.

## 0.26.8

- The Groovy DSL is tested against the published plugins, and the README shows it.
  No change to the plugins.

## 0.26.7

- `docs/metric.md` defines Mutation-CRAP version 1: the formula, the score policies, the states without a score,
  the limits of the value and of a gate.
  No change to the plugins.

## 0.26.6

- Kotlin/JVM basis methods are tested with Kotlin 2.4.21; ADR 0009 lists what each Kotlin construct gives in the report,
  and the limits for inline and suspend functions.
  No change to the plugins.

## 0.26.5

- Internal: werkcrappit builds with Temurin 25; the plugins stay Java 21 bytecode.

## 0.26.4

- Internal: no change to the plugins; the README names the current version, status, users and the demo in werkprobe.

## 0.26.3

- The code city's `index.html` has the style of `structure.html` and `matrix.html` (RFC 0003):
  the same header with the tabs "Code City", "Structure" and "Matrix", cards for the views, panels and footer.

## 0.26.2

- Internal: no change to the plugins; RFC 0003 explains where the CodeCharta viewer can come from,
  with the facts checked on 2026-10-11.

## 0.26.1

- Internal: no change to the plugins' behaviour.
  werkcrappit's nightly mutation build passes its gate again, writes the code city before the gate,
  and measures itself with the Gradle plugin 0.26.0, so its code city gets `structure.html` and `matrix.html`.

## 0.26.0

- `structure.html` and `matrix.html` mark every edge of a package cycle, not only the one against the levels (RFC 0003):
  red across the hierarchy, between sibling packages; amber along it, between a package and the classes of a package above it.
  The overview counts both kinds apart.

## 0.25.3

- Internal: no change to the plugins; the plan of werkcrappit as a Werkbaum file, and the shared workflow in sync.

## 0.25.2

- Internal: no change to the plugins; the agent instructions follow the workflow that all werk repositories share.

## 0.25.1

- No change to the plugins.
  RFC 0003 records as a follow-up the CodeCharta viewer beside the city, so that no link to javagil.de is needed;
  where it is bundled is still to be discussed.

## 0.25.0

- The CodeCharta export also writes `matrix.html` (RFC 0003, step 2):
  a dependency matrix that starts with the top package's children and opens package by package, in place;
  rows and columns by level, cycles in red, against the levels dark red.
  Column heads name the packages at 90 degrees; a chip colours the rows by LCOM4 or change risk;
  the open packages are in the URL; "Expand all" is off above 500 classes.
- `index.html` gets the button "Matrix"; the structure page and the matrix have the tabs "Code City", "Structure" and "Matrix".

## 0.24.0

- The CodeCharta export writes `structure.html` beside `index.html` (RFC 0003, step 1): one level diagram per package,
  with the packages that use it and those it uses, complexity as height, LCOM4 as fill, and cycles in red.
  The page draws with an inline script from inline JSON, loads nothing, and works from disk.
  `index.html` links it with the button "Structure", also when opened from disk.
- `Levelization` keeps the classes of each cycle;
  it runs also with `codeCharta.levelization = false`, which only leaves its fields out of the city.
- The browser tests, `./gradlew :werkcrappit-pit:browserTest`, run the page in a headless Chromium of Playwright,
  kept in `.playwright/`.

## 0.23.2

- No change to the plugins; the views below are planned, not yet built.
  RFC 0003, now accepted, plans for each level diagram the packages outside that use the package and those it uses,
  with the classes behind a package cycle in red.
  It plans the levels as rows, the highest on top, one package at a time with a breadcrumb back up,
  red always for "in a cycle", and the style of Werkator's pages.
  It plans a second view, an expandable dependency matrix, with a tab of its own.

## 0.23.1

- No change to the plugins.
  RFC 0003 proposes a structure view beside the code city: one level diagram per package,
  with complexity as height, LCOM4 as colour and cycles in red.

## 0.23.0

- The code city page leads with four buttons, one per view: Mutation-CRAP, cohesion, coupling and change risk,
  each with one sentence on its colour.
  The download and the upload by hand follow under "Without a direct link";
  opened from disk, the page says that only the download works there.

## 0.22.3

- No change to the plugins.
  The README names the current version; the hsadmin-ng guide shows the integration after hsadmin-ng's PR#317: the gate at 10, the export before the gate, and the published code city.

## 0.22.2

- No change to the plugins. The README explains how to choose a limit: a higher limit also allows weaker tests; Kotlin's generated branches are a reason to raise it, code that only coding agents change is none.

## 0.22.1

- No change to the plugins. werkcrappit's nightly mutation build uses the Gradle plugin 0.22.0, whose gate reads the report schema version 3.

## 0.22.0

- Change risk per class (ADR 0008): Mutation-CRAP over all scored methods of a top-level class, complexity and mutants summed, times `1 + (LCOM4 − 1) / 2` and `1 + Ce / 20`, as an exact fraction; a class with an `INCONCLUSIVE` method or one without complexity has none, with the reason.
  `mutation-crap.json` has schema version 3: each entry of `classes` adds `complexity`, `killed`, `denominator`, `mutationScore`, `changeRisk`, `changeRiskExact` and `changeRiskReasons`; the gate and the export read version 3 only.
  `mutation-crap.md` lists the ten classes with the highest change risk. The gate does not judge it.
- CodeCharta: the metric `change_risk` and a fourth scenario, `change-risk.ccscenario`, yellow from 30 and red from 100; the report page opens the city coloured by it.

## 0.21.0

- CodeCharta: the export writes three scenarios beside the city, `mutation-crap.ccscenario`, `cohesion.ccscenario` and `coupling.ccscenario`, one per view with its own colour band (coupling from half and 90 % of `maxEfferentCoupling`, none without it); the Mutation-CRAP link of the report page passes them to the viewer with `scenario=…`, and the page offers them for import by hand.

## 0.20.1

- No change to the plugins. werkcrappit's nightly mutation build also fails above an LCOM4 of 3 and an outgoing coupling of 21, today's highest values.

## 0.20.0

- The gate judges cohesion and coupling (RFC 0002, step 3): `werkcrappit { maxLcom4 = …; maxEfferentCoupling = … }`, both optional; unset, a dimension is only reported, and the gate judges Mutation-CRAP only when `maxMutationCrap` is set. A violation names its class and dimension; the failure line now says "N limit(s) exceeded".
- LCOM4 leaves out groups of methods that use no instance field at all, such as a `toString` through a static helper or a bean factory; a class with only such methods has no LCOM4.

## 0.19.0

- CodeCharta: the city has the metrics `lcom4`, `efferent_coupling` and `afferent_coupling` from the report's section `classes` (RFC 0002, step 2); the report page opens the city coloured by Mutation-CRAP, by cohesion (1 green, 2 yellow, from 3 red) or by coupling.

## 0.18.0

- The report measures cohesion and coupling per top-level class beside Mutation-CRAP (RFC 0002, step 1): LCOM4 with its method groups, records counted without their generated accessors, and the efferent and afferent coupling among the classes of the analysed code; `mutation-crap.json` has schema version 2 with a section `classes`, `mutation-crap.md` a section "Cohesion and Coupling". Mutation-CRAP is unchanged; the gate and the CodeCharta export read version 2.

## 0.17.0

- CodeCharta: with `codeCharta { colorRedFrom = … }` set, yellow starts at its half, not at half of `maxMutationCrap`; a ratchet such as `maxMutationCrap = 650` with `colorRedFrom = 12` now links `colorFrom=6&colorTo=12` instead of no yellow at all.
- CodeCharta: `codeCharta { colorYellowFrom = … }` sets where yellow starts, at most where red starts.

## 0.16.5

- No change for users. RFC 0002 proposes cohesion (LCOM4) and coupling (Ca, Ce) per class beside Mutation-CRAP, with gates of their own.

## 0.16.4

- No change for users. Every class of werkcrappit-pit is below a Mutation-CRAP of 10: the levelization, the JSON writer and the Markdown report are split along their domain steps, and the gate only asks whether any method was scored; the nightly mutation build fails above 9.

## 0.16.3

- No change for users. The four complex methods of werkcrappit's own hotspots are split; its nightly mutation build now fails above a Mutation-CRAP of 11.

## 0.16.2

- Fix: `Json.compact`, which computes the checksum of the code city, threw a `NullPointerException` on a `null` value.
- No other change for users. werkcrappit's own hotspots got tests and smaller methods; its nightly mutation build now fails above a Mutation-CRAP of 20.

## 0.16.1

- No change to the plugins. werkcrappit measures itself: a nightly Werkator build `mutation` runs PIT with werkcrappit on `werkcrappit-pit` and keeps the reports and the code city.

## 0.16.0

- CodeCharta: the link of the report page shows red from 90 % of `maxMutationCrap` on, 9 for 10, a buffer before the build fails; yellow from its half; `codeCharta { colorRedFrom = … }` sets another start, at most the limit.

## 0.15.2

- Fix: the progress lines of 0.15.0 never appeared while PIT ran, and the last one said `0:00:00`; PIT's start time is `System.nanoTime()`, which the listener compared with the wall-clock time.

## 0.15.1

- CI only: werkcrappit's builds on werkator.javagil.de stop after 10 minutes; the host allows hours since the nightly mutation build of Werkator.

## 0.15.0

- The PIT listener writes the progress of a run to the console, at most once a minute: classes and mutants so far, of about the total of the previous finished report, and the elapsed time; a last line closes it before the summary.

## 0.14.1

- CodeCharta: a class without any method with code, such as an interface, is linked at line 1 of its source file instead of not at all.

## 0.14.0

- CodeCharta: the city names the analysed commit as `meta.commitHash`, `git rev-parse HEAD` or `werkcrappit { codeCharta { commit = "…" } }`, and warns about uncommitted changes (RFC 0001 step 3).
- CodeCharta: `codeCharta { sourceLinkTemplate = "https://…/src/commit/{commit}/{path}#L{line}" }` gives every building a link to its source file at the analysed commit, at the method with the highest Mutation-CRAP.

## 0.13.0

- CodeCharta: the link of the report page sets the colour range to the gate in hard steps, red from `maxMutationCrap` on and green below its half, 5 and 10 without a limit; the viewer at javagil.de reads `colorFrom`, `colorTo` and `colorMode`, codecharta.com ignores them.

## 0.12.0

- CodeCharta: the direct dependencies between classes are edges with the metric `dependencies`, the distinct things one class uses of another (RFC 0001 step 2).
  By default they carry `isCyclic` and `isPointingUpwards`, and every node its dependency level, as CodeCharta's own dependency parser writes them.
  `werkcrappit { codeCharta { levelization = false } }` leaves these out for the released viewer at codecharta.com, which refuses them.

## 0.11.1

- Documentation only: RFC 0001 marks its "no CodeCharta fork" as outdated; ADR 0007 states why the fork is used and what its license asks, instead of calling it a deviation from the RFC.

## 0.11.0

- CodeCharta: the report page links, by default, `https://javagil.de/codecharta/`, a CodeCharta with a fix that shows classes without a score grey and keeps their height.
  `werkcrappit { codeCharta { viewerUrl = "https://codecharta.com/visualization/app/index.html" } }` links the original instead.

## 0.10.1

- CodeCharta: the report page and the description of `mutation_crap` say that the viewer shows a class without a score green, as 0, and that the rule *Flatten* where `mutation_crap` < 1 draws these classes grey.
  0.9.0 claimed they would be grey by themselves.

## 0.10.0

- CodeCharta: served over http(s), the code city's `index.html` links "Open in CodeCharta": the viewer loads the file by its URL and maps area, height and color itself.
  The server must allow `https://codecharta.com` by CORS; opened from disk the page shows the download only.

## 0.9.0

- CodeCharta: every class of the code roots is a building, also one outside the PIT run, such as a repository PIT excludes, and one without code, such as an interface.
  Classes outside the PIT run get complexity and executable lines from JaCoCo and no `mutation_crap`, so CodeCharta draws them grey.
- New option `werkcrappit { codeCharta { excludeClasses = listOf("**.generated.**") } }` leaves classes out of the city.

## 0.8.0

- CodeCharta: the area is `rloc`, the lines of the source file that are neither blank nor comment, as `ccsh` counts them; annotations and imports count, code Lombok generates does not.
- CodeCharta: the bytecode-based metric `loc` is now called `executable_lines` (eLOC), as CodeCharta's `loc` means all lines.

## 0.7.0

- CodeCharta: a package shows the median of `mutation_crap` and `max_method_complexity` of its classes instead of their sum, which turned every large package red.
- CodeCharta: a chain of packages without classes of their own, such as `net.hostsharing.hsadminng`, becomes one district, as an IDE compacts middle packages.

## 0.6.0

- `mutationCrapCodeCharta` writes to a report directory of its own, `build/reports/codecharta`, with an `index.html` beside `mutation-crap.cc.json`.
  The page links the file and the CodeCharta viewer and says which metric belongs to area, height and color.
  CI servers that list report directories by their index page, such as Werkator, show the code city without any change of their own.

## 0.5.0

- New task `mutationCrapCodeCharta`: writes `mutation-crap.cc.json`, a code city for CodeCharta (`vis-2.7.0`), from the finished report.
  Packages are districts, top-level classes buildings; executable lines are the area, the summed complexity the height, the highest method Mutation-CRAP the color.
  Dependency edges, commit metadata and source links follow (RFC 0001).

## 0.4.1

- README: what the name means and what Werkcrappit does, as in the repository description.

## 0.4.0

- Everything moves to `de.javagil.werkcrappit`: Maven group, Java packages and the Gradle plugin id `de.javagil.werkcrappit`.
  The project lives at git.javagil.de.
  Builds using 0.3.1 or older keep working with the old coordinates `de.hoennig.werkcrappit`, which get no new versions.

## 0.3.1

- Guide for integrating werkcrappit into hsadmin-ng, with the results of a probe run.

## 0.3.0

- New default status policy `timeouts-killed-v1`: a `TIMED_OUT` mutant counts as killed, as in PIT's own mutation score.
  `strict-v1` stays available through `werkcrappit { scorePolicy = "strict-v1" }` or the PIT plugin option `werkcrappit.scorePolicy`.

## 0.2.0

- Published to the Gitea Maven registry of git.javagil.de after every green `main` build.

## 0.1.0

- PIT plugin with output format `WERKCRAPPIT_MUTATION_CRAP`: Mutation-CRAP per JVM method from PIT results and the JaCoCo complexity of the original class files, status policy `strict-v1`.
- `mutation-crap.json` (schema version 1), `mutation-crap.md` and a console summary.
- Gradle plugin `de.javagil.werkcrappit` with the opt-in gate `mutationCrapCheck`.