CodeEraser

CodeEraser™

LLMs write code that accretes — duplicated blocks, dead files, stale docs, structural sprawl. CodeEraser measures it, judges it, and gates it with a score that is only allowed to get better.

Installer GitHub Releases — Windows · Linux · macOS, GUI + CLI + judgment core, SHA256-pinned

Cargo cargo install codeeraser

Claude Code /plugin marketplace add skymanbp/CodeEraser

$ ce check --roast
check score 950/1000 | axes 0:35 1:0 2:119 3:0 4:0 5:0 6:200 | 51 candidates
ratchet: 0 added, 0 removed, 0 over, 19 tolerance drawn -> pass
note: 102 blocks collapsed into existing members, 57 intra-file pairs off the sim table
roast: suspiciously clean. who did you pay?

Real output — CodeEraser judging its own repository. The ratchet only shrinks: every violation is banked in a baseline, and new entropy fails the gate.

See it work

CodeEraser GUI: squarified structure treemap of the CodeEraser repository, tiles heated by findings density, score 854/1000 — The structure screen judging this repository: a squarified treemap, tiles heated by findings density, one ratcheted score.

CodeEraser GUI: structure tree view with subtree-heat rail, per-directory findings chips and inline axis tags — The same judgment as a tree: subtree trouble rolls up into the heat rail, and every row names its axes.

CodeEraser GUI: deletion-candidate browser listing similar file pairs with block and token counts — The deletion-candidate browser: similarity × graph position × churn, the same rows `ce join` prints.

Wire it in

CI gate ce check . --fail-under 950 # ratchet + floor; exit 1 turns the pipeline red

pre-commit ce precommit # staged net LOC + touched duplicates

MCP ce mcp # every report family as a read-only tool for any agent

Judgment families

ce check

The gate. One 0–1000 score over seven axes, a shrink-only ratchet against the banked baseline, and a hard floor for CI.

ce dedup

T1/T2 clone detection via winnowing fingerprints, with a clone-block budget your repo can only ratchet down.

ce clone

T3 near-clones judged by tree edit distance in the Haskell core — renamed and reshaped copies included.

ce deadcode

Liveness verdicts on a cached reference graph: no kept in-edge, no entry flag — dead, and the gate says so.

ce docdup

Duplicated prose across docs and comments, judged by exact Jaccard over live segments.

ce structure

Tree-scale entropy: layout divergence, doc staleness, redundancy axes over the whole repository.

ce scan

Size, complexity and readability per file and function — the classic metrics, core-graded.

ce trend

Your score across mainline history — cached per commit, rebuildable, honest about direction.

Guard hooks

As a Claude Code plugin: duplicate writes intercepted at the moment of writing, audits at stop, health at session start.

Measured · v1.0.0

hook probe p5041 ms

full scan p50771 ms

incremental index p50 (warm)687 ms

guard false positives (630 arbitrated events)0.00 per 500 edits

docdup precision (frozen golden set)17/17 scoped (100%)

Every number is produced by replay (cli/tests/bench.rs) from one source, contracts/bench/bench.json — never hand-filled.

Complete evaluation dashboard →

Under the hood

Architecture: repository sources measured by the Rust frontend (tree-sitter, winnowing index, reference graph, churn, warm daemon), judged by the Haskell core (entropy, clones, liveness, doc duplication, ratcheted score), rendered by five faces (terminal, GUI, MCP, hooks, CI) — Measurement in Rust, judgment in Haskell — one wire, one report schema per family, five faces.

Open the component-level stack and its enforcement map →

Trust anchor

All nine release binaries — three platforms × ce / ce-core, plus the three GUI installers since v0.7.3 — are pinned by SHA256 in plugin/bin/manifest.env; the tag phase verifies every pin, waits for a green CI on the tagged commit, and refuses an unexpected asset before anything publishes. SHA256SUMS covers the set for offline checking. Code signing is deliberately out of scope — the hash chain is the permanent anchor. Measurement lives in Rust, judgment in Haskell, and this repository gates itself with its own tool on every commit.