Compare a workspace with a baseline, such as the branch a pull request
will merge into, so that CI can fail on what a change introduces rather
than on problems that were already there.

Change thresholds map a metric key to a vector of rules applied to the
change in a brick's metric since the baseline:

- {:rule :max-increase :value n} flags an increase of more than n. A brick
  that is new since the baseline counts its whole value as the increase.
- {:rule :max-increase-percent :value p} flags an increase of more than p
  percent. It is skipped for bricks that are new or were zero.

Rules take an optional :level, :error (the default) or :warning.

Command line entry point. Measures every brick of a Polylith workspace,
checks the measurements against thresholds, optionally compares them with
a base revision, and writes an HTML report or a GitHub Actions report.

Co-change coupling from Git history: bricks that keep changing in the
same commits are coupled, whatever their requires say. The pairs worth
reporting are those with no dependency path between them, which is
coupling the source doesn't show.

Cohesion within bricks, from the symbols each definition references.

- Cohesion: references to the brick's own namespaces / references to any
  workspace namespace. References to other libraries don't count.

Connascence between bricks: the static kinds that can be read from
source. Connascence within a brick is expected; between bricks it is
coupling.

- Position: interface functions that other bricks call with many
  positional parameters, so callers depend on their order.
- Meaning: keywords used in more than one brick, which are usually map
  keys that the bricks must agree on.
- Algorithm: the same code, of at least some size, in more than one
  brick.

Error surface: the interface definitions of each component that can
throw. A definition throws if its body contains throw, or refers to a
definition that throws, in its own brick or another. Catching isn't
taken into account, so this is an upper bound.

Brick dependency metrics from namespace requires, after Robert Martin's
package metrics, adapted to Polylith: a brick depends on an interface, and
so on every component that implements it.

- Afferent (Ca): bricks that depend on this brick's interface.
- Efferent (Ce): interfaces this brick depends on.
- Instability: Ce / (Ca + Ce), undefined for a brick with neither.
- Abstractness: 1 - interface definitions / all definitions. A small
  interface over a large implementation is abstract; bases are 0.
- Cohesion: references to the brick's own namespaces / references to any
  workspace namespace.
- Shared keywords: keywords this brick uses that another brick also
  uses, usually map keys the bricks must agree on (connascence of
  meaning).
- Libraries: libraries outside the workspace the brick requires, and
  shared libraries, those another brick also requires.
- Error surface: a component's interface definitions that can throw,
  directly or through what they refer to.
- Untested interface: a component's interface definitions that no test
  in the workspace mentions.

Dependency rules map a check to a level (:error or :warning), or to nil to
turn it off:

- :stable-dependencies flags a dependency on a less stable brick (the
  Stable Dependencies Principle).
- :new-dependencies flags a dependency that is not in the base, when
  comparing with one (applied by the baseline component).
- :mutable-state flags top-level atoms, refs, agents, volatiles, and
  dynamic vars, and alter-var-root calls, in components.
- :broad-catch flags catch clauses for Exception, RuntimeException,
  Throwable, or Object in components.
- :test-boundary flags a require, in a brick's tests, of another brick's
  namespace other than its interface.

Five rules take settings as a map with :level:

- :connascence-of-position {:max n} flags interface functions that other
  bricks call with more than n positional parameters.
- :duplicate-code {:min-forms n} flags code of at least n forms that
  appears in more than one brick (connascence of algorithm).
- :merge-candidates {:max-size r} flags a component whose only dependent
  is another component, when its forms are at most r times the
  dependent's.
- :co-change {:since s :min-shared n :min-strength r
  :max-bricks-per-commit m} flags two bricks with no dependency path
  between them that changed together in at least n commits since s,
  and in at least r of the less changed brick's commits. Commits that
  touch more than m bricks don't count. check reads the commits from the
  analysis's :commits, each a set of changed paths, and skips the rule
  without them.
- :library-spread {:max-bricks n} flags each require of a library outside
  the workspace that more than n bricks require.

Library spread: the bricks that require each library outside the
workspace. A library wrapped by one brick can be replaced or upgraded in
one place; one spread across bricks, such as a database driver, means a
missing gateway component.

Map namespaces to Polylith interfaces.

Tests seen from the workspace: interface definitions no test mentions,
and tests that reach into another brick's implementation rather than
its interface.

Read revisions and changes from the Git repository containing a
workspace.

Render a report for GitHub Actions: workflow command annotations and a
Markdown job summary.

A report is a map of :workspace (a name), :bricks (measurements from the
metrics component), :violations (from the thresholds component), and
optionally :graph-violations, the violations the dependency graph draws
when :violations leaves some out.

Render a report as a standalone HTML page.

A report is a map of :workspace (a name), :generated-at (a string),
:bricks (measurements from the metrics component), :violations (from the
thresholds component), :thresholds (the rules that were applied), and
optionally :graph-violations, the violations the dependency graph draws
when :violations leaves some out.

Measure Clojure source files and Polylith bricks.

Read Clojure source into rewrite-clj nodes, preserving everything the
reader would discard (comments, whitespace, reader macros) so metrics
can see the code as written.

Render a report as plain text for a terminal, such as a Git hook.

A report is a map of :bricks (measurements from the metrics component),
:violations (from the thresholds component), and, when compared with a
base, :comparison (from the baseline component).

Compare brick and function measurements to threshold rules.

Configuration has two maps from metric key to a vector of rules:
:brick-thresholds for brick metrics and :function-thresholds for each
function's metrics. Each rule is a map with a :rule type, a :value, and an
optional :level (:error, the default, or :warning):

- {:rule :max :value n} flags a value above n.
- {:rule :min :value n} flags a value below n.
- {:rule :std-devs :value k} flags a brick whose metric is more than k
  standard deviations above the mean of the other bricks of the same type
  (components are compared with components, bases with bases). It needs
  at least :min-peers other bricks (default 3) and is skipped otherwise.
  Brick thresholds only.

Brick rules take an optional :types, a set of brick types (:component,
:base) the rule applies to. Rules skip metrics with no value.

Discover the bricks of a Polylith workspace.