42 roadmap steps across 9 items · 10 issue fixes · 34 other changes
grit v0.5.16 adds change ids on every commit and richer log, show, diff and status output, plus Windows fixes and speedups.
Adds a documented daily functionality matrix tying grit-lib areas and grit commands to benchmark scenario ids, with automated coverage against the live CLI and registry. The larger stack also supplies daily worktree/history/remote scenarios and deterministic fixtures; round 2 makes smoke gaps visible, rejects non-executable selections, rejects failed timing samples, and validates HTTP push parity on remote state.
Adds library-level diff detail modes and modern CLI renderings for stat, numstat, shortstat, name-only, and name-status, including totals and rename similarity. The latest fix repairs worktree rename detection and removes duplicate staged/unstaged discovery traversals, but introduces a hygiene-gate failure and does not close the required name-only performance gap.
Adds patch, stat, name-only, and name-status detail to `grit log`, with stable per-commit `files[]` and totals in JSON and matching human/Markdown renderers. The implementation centralizes file-diff construction in grit-lib, batches ordered commit diffs with serial/parallel policy support, and also consolidates `grit diff` detail rendering.
Adds multi-object `grit show`, shared-resolver `REV:path` blob/tree display, and selectable first-parent or structured combined merge diffs. JSON keeps the single-object shape and wraps multiple results, while combined lines expose parent markers and correct line kinds; round-6 fixes restore raw binary stdout and align schemas/snapshots.
Adds a dedicated fat-LTO `dist` profile for shipped and benchmarked Grit binaries while preserving fast non-LTO `release` builds for development and release-mode tests. Release packaging, Make targets, benchmark binary resolution, and methodology docs are wired to that split.
Refreshes the dashboard benchmark evidence and adds a polling-independent headline suite with RSS measurements. The latest amendment restores real wall-clock timeout accounting and adds a regression test, but that amendment has not reached the exact Mesh integration source.
This stack adds shared revision-selection arguments to `log` and `revs`, range/date/ref-set support, resumable log cursors, and left/right counts. Round-4 removes a reentrant pack-reader cache and finishes since-cutoff walks correctly, but its cursor validation makes encoded range/date/ref cursors non-standalone.
Adds reusable commit author, committer, and message filtering to revwalk and exposes it through modern `log` and `revs` flags, including mailmap handling and typed invalid-pattern errors. It also contains substantial revwalk, commit-graph, pack-index, and ODB hot-path work intended to make bounded filtered logs competitive with Git.
The review branch is empty: it points at the exact same commit as origin/main, where the log display correctness work is already integrated. The current implementation correctly renders decorations and empty JSON and groups authors compatibly, but its count-only git.git path is still substantially slower than the acceptance target.
Adds a committed 11-scenario revision-selection benchmark baseline, publishes it through the docs benchmark tables, and registers 9 revision-selection workloads as their own daily census group. The review fixes make smoke runs use the small fixture, give commit-graph and no-graph rows genuinely different repositories, and preserve pending-row filtering coverage with synthetic plans.
Adds library-first pickaxe filtering for revision walks and exposes `-S`/`-G` through `grit log` and `grit revs`, including path and bounded-walk behavior. The round-3 patch replaces Rust leftmost-first regex matching with POSIX ERE semantics and restores Git-compatible relative shallow-fetch boundaries.
Adds a library-owned topological graph walk and lane layout, then renders it for human `grit log --graph` output while keeping JSON rejected and Markdown graph-free. It also carries the associated shared commit display/filter/grouping work, schema updates, snapshots, compatibility tests, docs, and benchmark registration present in the reviewed stack.
Adds a public change-ID model for stable logical commit identity, including reverse-hex generation/parsing, deterministic fallback derivation, commit-header read/write helpers, config policy, and injectable randomness. It documents the API and verifies ordinary and SSH-signed commit interoperability with system Git.
History rewrite planning now gives rewritten commits a stable logical identity. Existing primary, legacy, and custom commit headers survive rewrites byte-for-byte except cryptographic signatures; headerless rewrites store the deterministic id of the original commit, while inserted split commits receive a fresh id.
New commits created through the porcelain commit API now receive stable change-id headers, including initial and merge-conclusion commits. Amend preserves an existing ID or derives one from a headerless old tip, while disabling grit.changeIds preserves Git-identical object bytes and auxiliary stash/notes commit writers remain generic and ID-free.
Commit change IDs now travel from parsed commit data through shared library summaries into log, show, revs, and status JSON. Human and Markdown log/show output expose an eight-character change code while oneline output remains unchanged.
Clean merges and single-commit replay now stamp commit objects with a newly generated change-id before writing them. Pick never carries the source id, revert gets its own id, pull inherits clean-merge behavior, and command docs state the policy.
History rewrites now optionally re-sign every replacement commit through the same serialization/signing path used by normal commits. CLI dry runs explicitly disable signing, while normal rewrites honor commit.gpgsign and abort planning with a typed error if signing fails.
Mutation outcomes now carry the commit's logical change id through grit-lib and expose it consistently in commit, merge, pull, pick, revert, and history JSON/Markdown output. The review follow-up also preserves derived ids when rewriting headerless Git commits and repairs all enum-pattern, snapshot, schema, and unborn-pull gaps identified in round 1.
This adds reverse-hex change ids and unique prefixes as shared revision bases, allowing navigation and ranges to compose through existing rev-parse. It also adds typed ambiguity metadata, CLI rendering in three object-inspection commands, focused tests, docs, and a daily git.git benchmark row.
Adds one end-to-end CLI workflow proving stable change ids survive amend and history rewrites, while pick and revert allocate new ids and change-id prefixes resolve correctly. It also documents the on-disk header, Git/Jujutsu/GitButler/Gerrit interoperability, configuration, JSON fields, and revision syntax.
This separates corruption checksums from Git object identities while preserving SHA-1/SHA-256 bytes and streaming behavior. The review follow-up closes the two remaining leaks by moving the production index trailer and the large-pack test helper to ChecksumHasher, then adds a source-level regression guard.
Adds separate Criterion coverage for raw digests, Git object IDs, and hashing-writer checksums, plus a reproducible end-to-end hash benchmark suite against system Git. The follow-up correctly labels the library-driven hash-object row and makes the benchmark executable injectable.
SHA-1 object IDs on ingestion now use sha1dc collision detection and return a typed HashCollision error, while checksum-only hashing remains on the accelerated plain SHA-1 path. The round-two fix closes the raw loose-object bypass by parsing serialized objects and checking their typed payload before storage, and records all new public interfaces in the API snapshot.
The CLI now emits a stable `hash_collision` JSON error with the colliding digest while keeping grit's own human wording. Repository fsck exposes detected SHA-1 chosen-prefix collisions consistently in human, JSON, and Markdown output, and fetch/pull avoid remapping unrelated remote errors.
Adds a standalone nightly cargo-fuzz crate covering 14 grit-lib parser surfaces, real Git-generated seeds, and stable corpus replay so parser crashes become ordinary test regressions. The review follow-up closes the index short-body panic and makes scheduled fuzz failures retain crash artifacts while remaining non-blocking.
Adds optional operation-level spans throughout grit-lib and a minimal env-controlled stderr span-tree renderer in grit. With tracing disabled, grit-lib’s normal dependency graph excludes tracing; with `GRIT_TRACE=1`, status and related commands show nested operation durations.
Adds a public, typed path-component validator that centralizes ASCII, NTFS, HFS, separator, NUL, and symlinked special-file rules. Tree fsck and porcelain path normalization now consume that shared rule set, with unit and system-Git parity coverage.
This introduces one reusable grit-lib lock-file abstraction and migrates repository writers to exclusive acquisition with bounded, jittered retry. The round-2 patch corrects Git-compatible timeout units and negative timeout semantics, and makes explicit rollback actually release the owned lock.
Adds a public borrowed `CommitRef` that parses commit headers and message bytes without owning identity/message strings, then makes owned `parse_commit` a thin conversion. Hot commit-graph-miss paths use the borrowed view, while verbatim header preservation keeps every accepted commit body byte-identical on reserialization.
Adds specialized ObjectId hash maps and sets backed by hashbrown, then migrates OID-heavy internal caches and graph/pack/fsck/revwalk tables while preserving standard containers at public commit-graph boundaries. It also adds focused API tests and a 1M-key Criterion benchmark, but the insert benchmark currently gives only the new map a reserved capacity.
This change rejects hostile Git tree and index paths before they can populate an index or reach a checkout write, while preserving legitimate add pathspecs and allowing users to switch away from a hostile current index. It also returns a typed path-component error and applies repository `protectNTFS`/`protectHFS` configuration through restore, sparse-index, and related tree walks.
Adds borrowed tree entries and a zero-copy iterator over raw Git tree objects, then migrates object-walk, fsck, pack, rev-list, and diff hot paths to consume entries in place. Existing owning parse APIs remain available through the same parser, with malformed input and SHA-256 parity covered by tests.
Adds a caller-buffer ODB read API and native loose/pack implementations, then uses borrowed tree iteration in hot object walkers. The round-4 correction fixes delta-frame ordering and avoids unsafe LRU population from reusable buffers while preserving owned-read cache behavior.
Annotated tag objects now retain raw noncanonical headers after the canonical tagger and emit them unchanged. Shared raw-header utilities support iteration, multi-value lookup, replacement, and change-id header manipulation, while all TagData construction sites initialize the new field.
This adds cryptographically signed annotated tags through the public library API and the modern `grit tag` command. Signed tag objects append armored SSH or OpenPGP signatures after the tag message in Git's on-disk layout, and create JSON now reports whether signing occurred.
Status now reports typed conflict objects and a typed paused-merge operation model across the library and all CLI output formats. The round-3 correction separates abort from the ordered completion path, so following `next_steps` can no longer commit a merge and then attempt an invalid abort.
Adds one typed grit-lib resolver for command-line and file/stdin pathspecs, then routes add, rm, restore, and clean through shared CLI arguments. Empty and malformed records now fail before a scoped operation can accidentally target the whole work tree, while LF quoting and NUL literal behavior are covered against system Git.
Status now computes branch standing in grit-lib and keeps target and configured upstream as separate comparisons. The CLI renders target counts, a distinct upstream line, and pull hints from that typed result, while `--no-ahead-behind` and config can skip history walks.
Adds explicit commit scopes to the linkable library and exposes them through `grit commit`: auto-stage, staged-index-only, and Git-compatible path-only commits. Partial commits preserve unrelated staged entries, use a temporary hook index, update the real index only after the ref succeeds, and report a stable JSON scope.
Adds config-derived status options, path-limited status across staged/unstaged/untracked/conflict sections, default rename detection with old/new path reporting, and Git-style `-u` forms. Shared pathspec argument resolution remains library-first, while the CLI only normalizes argv, forwards resolved pathspecs, and renders the additive `old_path` JSON field.
Adds opt-in ignored-path collection, concise two-column human status output, and stash counts while keeping JSON stable except for the documented fields. The round-five repair makes ignored collection independent of untracked display and represents rename endpoints structurally so filenames containing ` -> ` cannot be reparsed incorrectly.
Worktree enumeration now strips Windows verbatim path prefixes from the main worktree when discovery starts in a linked checkout. All list renderers use a Git-style display path, and detached worktrees receive an explicit human label.
This change makes Windows worktree scanning reconcile directory-entry metadata with the same path-based stat representation Git records after clone. It also keeps successful scan metadata when the confirmation probe fails and ensures the reconciliation work is absent from non-Windows hot paths.
Populated worktree checkout now diffs the empty tree against the target and sends the resulting additions through grit's existing bulk/parallel checkout machinery. It removes the old serial blob-read/write walk and its dedicated progress adapter while preserving index construction and conversion rules.
Stash apply and pop now write regular files through the repository's worktree conversion rules instead of copying normalized object bytes directly. This preserves CRLF on disk with core.autocrlf=true for both tracked changes and include-untracked stash contents.
Repairs two stale Windows-only worktree scan paths so metadata is converted to the current compact stat type and the one-entry optimization uses the current index-based inputs. It also adds a PR CI check that type-checks grit-lib for the Windows MSVC target from Ubuntu.
This changes gc’s first-pack build from byte-reuse-only packing to normal delta search, so histories with repeatedly edited blobs no longer balloon when maintained. It also makes the full gc command actually silent under `-q` and adds a Git-backed regression test.
Loose ref deletion now removes its transaction lock before walking upward to remove empty ref directories. A regression test exercises pruning `origin/feature/x`, verifies the empty `feature/` directory disappears, then confirms a later fetch can create the file ref `origin/feature`.
Explicit garbage collection now always performs the same full repack as `grit repack`. Loose objects created after an existing pack are folded into the pack and redundant loose copies are removed instead of being silently skipped by auto-maintenance heuristics.
Merge now carries unrelated local edits and trusted worktree deletions across fast-forward, clean three-way, and conflicted integrations while still refusing paths the merge would overwrite. Pull inherits the same scoped behavior, replay operations retain their full clean-worktree checkout, and the generated CLI skill snapshot is current.
Ad-hoc path, URL, and bundle fetches no longer impersonate `origin`: they fetch objects without assigning configured remote-tracking destinations and write the selected result to FETCH_HEAD. Bundle completion and explicit refspec handling now share matched-ref-based FETCH_HEAD generation.
Repairs the Windows-only single-entry worktree scan after an earlier refactor left it referring to a removed collection and returning the wrong metadata type. The change reuses the current index-entry helpers and the same metadata conversion as the generic directory path.
Adds modern log display modes and shared structured commit output, with library-first author grouping and a specialized count-only pack scan. The round-3 fix correctly removes the `-n` lookahead before author grouping and adds a direct regression, but the optimized count path still does not meet its required release performance bound.
This change makes notes operations a repository-scoped, typed library API and routes note ref updates through the configured RefStore. It closes lost-update races by carrying the notes tip into a CAS and by holding all per-update files-backend write-target locks from validation through persistence, including symbolic HEAD updates.
Replaces the previous histogram line selection with a bounded Rust implementation that matches system Git’s hunk boundaries and cannot duplicate indexed line classes. It also fixes one-sided changed-flag tails and minimal repeated-anchor coalescing so zero-context diffs terminate and shape hunks like Git.
Removes unused dependencies and 537 net lines of private dead code across grit-lib and grit-cli. Test-only helpers are now compiled only for unit tests, stale dead-code suppressions are removed, and one checkout test that lacked #[test] is activated.
This adds multi-object show, REV:path lookup, shared diff-format rendering, and first-parent/combined merge display through grit-lib-backed APIs. The final fixes preserve raw binary blob bytes, correctly expose per-parent combined statuses, handle combined deletions, omit merge log stats like Git, and synchronize the generated JSON schemas.
This replaces repeated linear pathspec validation with a conservative binary-search path for ordinary literal specs, avoids per-comparison allocations in directory-prefix matching, and delays the HEAD tree walk until index/worktree paths cannot answer a spec. The CLI and public API are unchanged.
Centralizes strict commit/tag identity lines and best-effort reflog identity lines in grit-lib, then turns the CLI helpers into thin forwards. Repository-backed merge, checkout reflog, and notes paths now share the repository clock instead of rebuilding clock and environment logic independently.
This replaces the histogram unified-diff emission path with Git-compatible changed flags plus the shared unified emitter, while removing the obsolete imara conversion helper. It preserves shifted duplicate-line alignments and clears the clippy blocker found in round 2.
Log pagination hints now tell users to continue with only the opaque cursor, including on the first page of a revision range. Cursor continuation also rejects repeated revision, date, and ref-set selectors so the token is the sole source of the resumed query.
This change removes unchanged local tags from default tag-following before reachability analysis, and makes the remaining commit walk stop once every candidate tag target is found. It also caches ref backend detection and packed refs for the tag scan, eliminating two full-history walks on common incremental and no-op fetches.
Makes grit-bench ignore ESRCH when a process disappears between process-tree discovery and reading `/proc/<pid>/status`. Adds focused errno, exited-process, and high-churn process-tree regression tests; grit-lib and grit-cli behavior are unchanged.
This change replaces the slow author-grouping walk with pack-, bitmap-, and commit-graph-aware counting paths while retaining safe ODB fallbacks. The round-four correction ensures deltified commits cannot reuse a previous commit’s cached header bytes, so complete reachable history is counted without sacrificing the measured speedup.
Refreshes the committed performance matrix and dashboard data, adds daily headline/worktree benchmark coverage, and records the measured gaps in the docs. The reviewed follow-ups make capped runs report true parent-observed elapsed time and repair the malformed show-head snapshot.
Adds functional `grit diff --no-index` handling with correct line statistics, differ/error exit-code separation, and dashed-path support after `--`. It also repairs stale diff API tests/snapshots and scopes Clap parsing so ordinary diff flags and path limits are not mistaken for revisions.
Adds `grit clone --shallow` as a depth-1 clone backed by public library depth support, with human/JSON/Markdown output, documentation, and Git compatibility tests. Round 4 correctly restores annotated tags on the fetched tip without putting tag object IDs in `.git/shallow`, but the same logic drops annotated tags on non-tip commits that are still inside a depth greater than one.
Adds depth-limited clone support through the public library API and the modern `grit clone --shallow` flag. The follow-up makes default tag-following preserve annotated tags anywhere inside the fetched shallow commit closure—such as a depth-2 parent—without importing tags on unreachable history.
This branch restores the missing patch-text diff path, makes no-index patch output usable, honors worktree rename flags, and fixes the CI-specific canonical-module, Windows ERE, snapshot, schema, and public-API consistency issues. The round-3 addition records the new library API and directly exercises it from grit-lib.
Moves branch and tag listing/deletion policy and ref manipulation from grit-cli into documented grit-lib porcelain APIs. Deletion now uses repository-bound ref stores with compare-and-swap checks and reflog cleanup, including files, reftable, and injected memory backends; the round-3 store optimization removes the transaction overhead that previously made tag deletion unacceptably slower.
Deletes the unused second implementation of branch tracking/status comparison and its embedded Git-style prose. The remaining push-side tracking updater now reads one remote's fetch refspecs once per push instead of reloading config for every pushed ref.
Missing references now have a structured `RefStoreError::NotFound { name }` across every ref backend and public helper. Repository-backed HEAD resolution can therefore distinguish an unborn branch from corruption, while CLI rendering preserves branch-friendly messages without parsing error text.
Adds the three missing canonical-module mappings, fixes the Windows-only unused parameter and a private rustdoc link, preserves rustfmt import order, and updates the shared commit JSON shape assertion for change IDs. The changes are mechanical CI repairs with no production behavior change except eliminating a Windows compile warning.
This change removes stale persisted and in-memory negative change-id probe results, clears legacy `absent` markers, and invalidates probe state after relevant in-process ODB changes. It adds the requested regression proving a stored change id added after a headerless packed-repository probe resolves on both the same and a reopened repository handle.
This change keeps histogram hunk alignment compatible with stock Git 2.43 when `-w` or `-b` normalizes lines, while preserving the merged-group Myers rediff used by the raw histogram path. It also makes the Git-parity history reword test opt out of change IDs and applies the pending JSON formatting fix.
Local file clone and empty-bare push now serialize exactly the objects still absent after source packs are linked, instead of rewalking loose tag tips and repacking the entire reachable history. Pack lookup and peer-boundary probing are also made scalable by a cached offset-sorted index and one pack-directory refresh per walk.
This branch repairs the identified main-CI failures and makes status conflicts visible in human and Markdown output. The round-two patch aligns conflict formatting with other status sections and adds a realistic two-file merge-conflict regression test, including a path containing a backtick.
Stash apply and pop now return a library-owned outcome containing sorted, de-duplicated conflict paths, while the existing bool APIs remain thin compatibility wrappers. The CLI only maps that outcome into its unchanged human, Markdown, and JSON shapes, removing its duplicate stash lookup and second index read.
Introduces specialized hashbrown-backed maps and sets for ObjectId keys, then migrates object-heavy internal caches to them while preserving standard HashMap/HashSet at public API boundaries. The follow-up also restores collision-safe hashing/fsck reporting and lock waiting that had regressed during the migration, and makes the insertion benchmark capacity-fair.
This change makes the hostile-path coverage test find the instrumented grit binary, refreshes the stale generated-skill snapshot, and limits concurrent links in the debug workspace CI test step. It changes no product behavior, public API, or Git on-disk/wire format.
This change prepares literal pathspec lists once and matches index/tree paths with hash lookups instead of reparsing and scanning every pathspec for every entry. Restore keeps the existing general matcher for globs, magic, excludes, Unicode precomposition, and metadata-sensitive contexts.
Removes an unused EWAH XOR implementation and its dispatch/storage indirection, an ignored files-ref-store reflog setting, and several stale dead-code allowances or genuinely uncalled helpers. The result is 25 additions and 296 deletions across 19 files, with a substantially faster EWAH expansion path.
This makes histogram diffs with `-w`/`-b`-style comparison produce Git 2.55-compatible hunk bodies after change-group compaction. It also reduces the debug workspace test job to one concurrent Cargo build so lld does not repeat the observed signal-7 crashes.
This change replaces full packed-refs parsing on sorted prefix lookups with a validated line index and bounded strict scan. It also makes the tail safety check repository-hash-aware, so malformed SHA-256 packed-refs cannot silently produce an empty branch list.