GitoxideLabs/gitoxide

This system is a high-performance, modular implementation of Git written in Rust, designed to replace or extend the capabilities of the standard Git toolchain. It provides a comprehensive suite of libraries for parsing, verifying, and manipulating Git objects, repositories, and network protocols, while also offering advanced analytics and repository analysis engines. The codebase exposes these core functionalities through a structured CLI and a flexible API, enabling developers to build custom Git tools with fine-grained control over operations like diffing, merging, and credential management.

185 changes.

The project established a unified command-line interface by splitting the monolithic binary into dedicated 'gix' (plumbing) and 'ein' (porcelain) tools, supported by a new internal abstraction layer called gitoxide-core. This period also involved a comprehensive architectural shift to lifetime-free configuration handling, the introduction of SHA-256 support, and the expansion of the crate ecosystem with new modules for credentials, worktrees, and directory status.

81 changes.

This period focused on introducing major new capabilities to the gitoxide ecosystem, including the gix-blame crate for file history annotation, a Git-compatible directory walk implementation, and robust merge and diff algorithms. These features were accompanied by extensive test coverage, fuzzing infrastructure, and the introduction of a structured error handling system to ensure reliability and correctness across the library.

Users can now create linked worktrees via \Repository::add\_worktree()\, which supports attaching to a specific branch or a detached commit, respects the \worktree.useRelativePaths\ configuration, and provides progress reporting and interruption handling. Conversely, \Repository::prepare\_remove\_worktree()\ and \Target::remove()\ allow safe removal of linked worktrees, enforcing validation against dirty states, initialized submodules, and locks (configurable via \Force\), while ensuring the main worktree cannot be removed.

gix/src/worktree · high confidence

The \gix-fsck\ library now includes a new connectivity check feature that verifies the integrity of the object database. This check walks through trees and blobs referenced by a given commit, ensuring they exist in the object database. If any referenced blobs are missing, a callback is invoked, while missing commits or trees result in an error. This enhancement allows users to detect and report integrity issues within their Git repositories more effectively.

gix-fsck/src · high confidence

Users can now verify the integrity of commit-graph files through the new \verify\ module in \gitoxide-core\. This change introduces a \Context\ struct and a \verify\ function that checks graph integrity and optionally outputs statistics—either in human-readable format or JSON (when the \serde\ feature is enabled)—detailing parent counts and the longest path between commits.

gitoxide-core/src/commitgraph · high confidence

The gix-credentials crate now includes three example programs demonstrating how to interact with the credential system: custom-helper.rs shows how to implement a custom credential provider, git-credential-lite.rs demonstrates invoking the standard git-credential helper chain, and invoke-git-credential.rs provides a simple wrapper to call git credential directly. These examples serve as reference implementations for users integrating gix-credentials into their applications.

gix-credentials/examples · high confidence

A new fuzzing support library has been added to the gix-pack crate, providing helper functions for generating virtual file paths, managing interrupt flags, and defining empty candidate ranges to facilitate fuzz testing workflows.

gix-pack/fuzz · high confidence

Introduces a new \index()\ function in \gix-diff\ that computes the difference between two git index states (\lhs\ and \rhs\). This allows users to detect additions, deletions, modifications, and renames/copies (rewrites) between index entries, supporting pathspec filtering and configurable rewrite tracking options.

gix-diff/src/index · high confidence

The \eol\ filter module now exposes \convert\_to\_git()\ and \convert\_to\_worktree()\ functions to handle line-ending conversions (CRLF/LF) in a streaming-compatible manner. \convert\_to\_git()\ normalizes line endings to LF when adding files to the index, supporting round-trip checks to warn or fail if the conversion is not reversible, and respects \core.autocrlf\ and \core.eol\ settings. \convert\_to\_worktree()\ converts LF line endings to CRLF when checking out files, ensuring compatibility with Windows-style line endings. These changes enable more precise control over line-ending normalization during Git operations.

gix-filter/src/eol · high confidence

The \gix-filter\ crate now exposes functions to convert text between UTF-8 and specific worktree encodings (e.g., Latin-1, UTF-16) using the \encoding\_rs\ library. This includes \encode\_to\_worktree\ for writing files to the working directory and \encode\_to\_git\ for storing content in the repository, with optional round-trip validation to ensure data integrity.

gix-filter/src/worktree · high confidence

A new presentation titled 'Gitoxide: What it is, and isn't' has been added to the \etc/speak\ directory, containing both the source Markdown (\gitmerge-2024.marp.md\) and the compiled HTML output (\gitmerge-2024.marp.html\). The deck uses the Marp framework with the 'gaia' theme to explain the Gitoxide project's capabilities, aspirations, and current limitations, covering topics such as its high-performance Rust implementation, included features like object database handling and fetch support, and its adoption by tools like Cargo and Sapling.

etc/speak · high confidence

The \etc/corpus\ directory now includes a \README.md\ and supporting shell scripts (\clone-repos.sh\, \json-to-jsonl.sh\) that guide users in building a validation corpus of popular Git repositories. This enables developers to run \gitoxide\ algorithms against a diverse set of real-world repositories to verify performance and correctness.

etc/corpus · high confidence

The gix-bitmap crate now includes a fuzz testing setup for its EWAH bitmap decoding functionality. Users can run fuzz tests using cargo-fuzz to exercise the decoder, and the project provides corpus builder scripts to generate test inputs. Additionally, an integration test module allows reproducing known fuzz failures by running minimized reproducer inputs found in the artifacts directory.

gix-bitmap/fuzz · high confidence

Users can now edit physical Git configuration files atomically using the new \FileTransaction\ API, which ensures that changes are written safely without leaving the file in a partially written state. This capability is exposed via \Repository::config\_file\_mut()\ and the standalone \config\_mut()\ function, allowing modifications to persist directly to disk while maintaining file locks and respecting shared repository permissions.

gix/src/config · high confidence

The \gix/src/commit\ module now provides Git-compatible commit signing and signature verification capabilities. Users can sign commits via \Commit::sign()\ and verify existing signatures via \Commit::verify()\. The implementation supports OpenPGP, X509, and SSH signature formats, configuring the signing/verification programs and keys through standard Git configuration options (e.g., \gpg.format\, \user.signingKey\, \gpg.ssh.allowedSignersFile\). It also includes logic to locate bundled signature programs on Windows and handles trust levels for verification.

gix/src/commit · high confidence

The \gix-commitgraph\ crate is introduced as a new component for reading and writing Git commit-graph files. This release includes the initial implementation of the crate, its Apache-2.0 and MIT license files, and a comprehensive changelog documenting the project's history and versioning.

gix-commitgraph · high confidence

The \gix-dir\ crate is introduced as a new component of the gitoxide ecosystem, providing directory traversal and status functionality. This release establishes the foundational API for walking the working directory and comparing it against the index, enabling tools like \gix status\ to detect untracked, modified, or deleted files. The crate includes standard Apache-2.0 and MIT license files and follows semantic versioning starting at version 0.1.0.

(repo-wide) · high confidence

The gix-pathspec crate is introduced as a new component for parsing and matching Git-style pathspecs. This release includes a comprehensive fuzzing infrastructure with a corpus of 54 test cases covering various pathspec syntaxes, including magic keywords (glob, literal, icase, attr, exclude, top) and complex attribute specifications, ensuring robust parsing behavior from the start.

gix-pathspec · high confidence

The \gix-rebase\ crate has been introduced as a new, empty library (version 0.0.0) to reserve the package name for the gitoxide project. It currently contains no functional code, serving only as a structural placeholder with standard Apache-2.0 and MIT license files and a basic Rust 2021 edition setup.

gix-rebase · high confidence

The \gix-dir\ crate now includes a new, Git-compatible directory walk implementation located in \gix-dir/src/walk\. This replaces previous traversal logic with a structured approach that classifies entries, handles pathspec matching, and supports advanced features like directory collapsing, symlink handling, and interruption via a \should\_interrupt\ flag. Users benefit from more accurate behavior when traversing worktrees, submodules, and ignored paths, aligning with standard Git semantics.

gix-dir/src/walk · high confidence

The \gix-error\ crate now provides a new \Exn\ exception type that wraps errors into a tree structure, preserving call-site locations and supporting multiple causes via \raise\_all\. This change introduces extension traits (\ErrorExt\, \ResultExt\, \OptionExt\, \BoxedResultExt\) for ergonomic error handling, including methods like \raise\, \and\_raise\, \raise\_erased\, and \or\_raise\. The \Exn\ type is designed to work well with \anyhow\ for source-chain display, allowing users to create rich error contexts while maintaining compatibility with standard Rust error traits. New macros (\bail!\, \ensure!\, \message!\) are also provided for convenient error creation and propagation.

gix-error/src/exn · high confidence

Users can now traverse repository directories using a new \dirwalk\_iter()\ method that returns an iterator, providing a more ergonomic and potentially more efficient alternative to the previous callback-based approach. The iterator supports parallel execution when the \parallel\ feature is enabled, allowing for concurrent processing of directory entries, while falling back to a buffered serial mode otherwise. The iteration yields \Item\ structs containing directory entry details and optional collapsed directory status, and the final \Outcome\ exposes the traversal root, pathspecs, and exclusion stack for post-processing.

gix/src/dirwalk · high confidence

A new \hours\ module has been added to \gitoxide-core\ to provide functionality for estimating the time spent on repository contributions. This feature calculates estimated work hours based on commit timestamps and can optionally track file and line statistics (additions, removals, modifications). It supports multi-threaded processing for performance, handles author identity unification via mailmaps, and respects \Co-authored-by\ trailers to attribute work correctly across multiple contributors.

gitoxide-core/src/hours · high confidence

The new \gix-sec\ crate provides a shared trust model for gitoxide, defining \Trust\ (Full or Reduced) and \Permission\ (Allow, Deny, Forbid) types to control resource access. It introduces \identity::is\_path\_owned\_by\_current\_user\ to determine path ownership, featuring a Windows implementation that aligns with Git for Windows behavior and handles UAC scenarios, while also adding an \oauth\_refresh\_token\ field to the \identity::Account\ struct.

gix-sec · high confidence

The \src\ directory now provides two distinct command-line interfaces: \gix\, which exposes low-level plumbing commands via \gitoxide::plumbing::main()\, and \ein\, which provides high-level porcelain operations via \gitoxide::porcelain::main()\. Both binaries are gated behind the \pretty-cli\ feature flag and share a common codebase in \shared.rs\ for progress rendering and logging. Additionally, a new \uni\ multi-call binary is introduced, allowing users to invoke either \gix\ or \ein\ functionality from a single executable based on the binary's name, simplifying distribution and build steps.

src · high confidence

The \gix-filter\ crate now includes a new \ident\ module that implements the Git \$Id$\ keyword expansion. Users can apply this filter to substitute \$Id$\ placeholders with a hash of the content (via \ident::apply\) or revert them back to the placeholder (via \ident::undo\). This functionality is integrated into the filter pipeline, allowing automatic handling of these keywords based on repository attributes.

gix-filter/src · high confidence

The \gix-config\ crate now includes a new \format\ module that allows users to reformat git-config files by normalizing whitespace, indentation, and newlines while preserving values and comments. Additionally, a new \key\ module introduces the \AsKey\ trait and \KeyRef\ struct, enabling structured parsing and access to configuration keys (e.g., splitting \remote.origin.url\ into section, subsection, and value components) rather than treating them as opaque strings.

gix-config/src · high confidence

The \gitoxide-core\ corpus module now provides a structured engine to analyze collections of Git repositories. It introduces a SQLite-backed database to track runs, tasks, and repository metadata, enabling parallel execution of analysis tasks such as opening repositories, counting packed objects, and verifying object database integrity. The engine supports progress reporting, tracing integration, and a dry-run mode for previewing operations without side effects.

gitoxide-core/src/corpus · high confidence

The repository opening mechanism now exposes a structured \Options\ builder and a \Permissions\ type that allow users to explicitly control which configuration sources (system, user, git binary, environment) and environment variables are accessible when opening a repository. This enables isolated or secure opening modes where access to external configuration and environment overrides is restricted, improving security and predictability for applications handling untrusted repositories.

gix/src/open · high confidence

Added a new query engine in \gitoxide-core\ that indexes repository history into a SQLite database to enable analytics queries. This includes a \TracePath\ command that traces a file's history through commits, displaying commit times, file modes, and diff statistics (lines added/removed) for each change. The engine uses parallel processing to extract stats and diff lines, leveraging \gix-diff\ for change detection and \rusqlite\ for persistent storage of commit-file relationships.

gitoxide-core/src/query/engine · high confidence

Users can now utilize a new git analytics engine located in \gitoxide-core/src/query\. This feature introduces a local SQLite database (\ein.query\) to store commit and file change data, including line additions/removals and diff status. The engine supports configurable options such as object cache size, copy detection settings, and thread count, enabling efficient querying of repository history for analytics purposes.

gitoxide-core/src/query · high confidence

The \gitoxide-core\ crate is introduced to abstract the user interface of the \gix\ command-line tool from its underlying implementation, enabling the creation of alternative frontends. This crate is explicitly internal and not intended for external consumption via \cargo\. It provides core modules for repository discovery (\discover\), mailmap verification (\mailmap\), network connectivity (\net\), repository organization (\organize\), and remote reference management (\remote\), along with utilities for environment inspection (\env\) and trust verification (\trust\).

gitoxide-core/src · high confidence

A new \gix-archive\ crate has been added, providing the ability to create archives from a worktree stream in \tar\, \tar.gz\, and \zip\ formats. The \tar\ and \tar.gz\ implementations are basic and require the output stream to be seekable for large files only in the \zip\ variant (which uses \rawzip\). Users can configure compression levels and modification times via the \Options\ struct, and the crate supports feature flags to enable specific formats (\tar\, \tar\_gz\, \zip\).

gix-archive/src · high confidence

The new gix-attributes crate provides functionality to parse .gitattribute files and match patterns against file paths. It introduces core types like Assignment, State, and Name to represent attribute assignments, along with a Search API for pattern matching. The crate supports multiple attribute sources (installation, system, user, local) and includes robust parsing with validation for attribute names and values. Users can now programmatically work with git attributes in a type-safe manner, with support for serialization via serde and proper error handling through gix-error.

gix-attributes/src · high confidence

The \gix-bitmap\ crate is introduced to provide shared bitmap utilities for \gix-pack\, \gix-index\, and \gix-worktree\. It implements the EWAH (Extended Word-Aligned Hybrid) bitmap format, allowing users to decode bitmap data from byte slices and construct bitmaps from boolean sequences. The crate exposes methods to write bitmaps to output streams and iterate over set bits, replacing the previous \git-bitmap\ naming convention and adopting \gix-error\ for error handling.

gix-bitmap/src · high confidence

The new \gix-blame\ crate is added to the repository, providing the core functionality for git blame operations. This release includes the initial changelog and license files for the crate, marking the introduction of this capability to the gitoxide ecosystem.

gix-blame · high confidence

Adds the new \gix-blame\ crate, which implements an algorithm to annotate lines in tracked files with the commits that changed them. The library exposes a \file()\ function and supports configuring blame via \Options\, including specifying line ranges through \BlameRanges\ (supporting multiple 1-based inclusive ranges), setting a \since\ date filter, selecting a diff algorithm, and enabling rename tracking. It also provides \BlamePathEntry\ for debugging history traversal and returns \BlameEntry\ and \Statistics\ in the results.

gix-blame/src · high confidence

The gix-chunk crate has been added to provide low-level utilities for reading and writing chunk-based file formats, as defined by the git documentation. It exposes a public API including an \Id\ type for chunk identifiers, a \SENTINEL\ constant, and modules for handling file structures (\file\) and range conversions (\range\), enabling users to plan, write, and decode chunked data streams.

gix-chunk/src · high confidence

The new \gix-command\ crate provides a builder API for spawning processes with Git-specific behaviors, including automatic shell detection for scripts, safe argument splitting, and context injection (such as setting \GIT\_DIR\ or suppressing \stderr\). It also includes a POSIX-compliant command-line parser and Windows-specific path lookup logic to ensure commands are executed consistently with Git's behavior.

gix-command/src · high confidence

The new \gix-commitgraph\ crate provides functionality to read, verify, and traverse Git commit graphs. It introduces a \Graph\ type that manages one or more commit-graph files, offering methods to access commits by position or ID, iterate over commits and IDs, and verify the integrity of the graph structure. The crate also includes an \at()\ function for convenient instantiation from file paths or directories, and handles errors using the \gix-error\ crate.

gix-commitgraph/src · high confidence

The \gix-config-value\ crate now provides dedicated types for parsing Git configuration values, including \Boolean\, \Integer\, \Color\, and \Path\. Booleans are parsed case-insensitively from strings like 'yes', 'true', or '0', and also accept numeric values where zero is false. Integers support Git-style bases (hex, binary, octal) and binary suffixes (k, m, g). Colors handle standard names, bright variants, ANSI codes, and 12-bit hex shorthands. Paths support interpolation of \\~\, \\~user\, and \%(prefix)\, and can be marked as optional using the \:(optional)\ prefix.

gix-config-value/src · high confidence

The \gix-credentials\ crate is introduced to provide functionality for interacting with git credentials and launching helper programs. It exposes a \Program\ struct to manage credential helper processes and a \helper\ module for constructing actions. The library includes a \builtin\ function that invokes the standard \git credential\ helper, allowing users to retrieve or store credentials based on a URL. This change also includes configuration for documentation generation via the \document-features\ feature flag.

gix-credentials/src · high confidence

The \gix-date\ library has been introduced to handle date and time parsing similar to Git's behavior. A key behavioral change is the support for dates prior to the UNIX epoch, represented using 64-bit signed integers (\i64\) for seconds since the epoch, allowing for negative values. The \Time\ struct now exposes \seconds\ (UTC) and \offset\ fields, and the crate provides \parse\ and \parse\_header\ functions for converting string representations into these time objects.

gix-date/src · high confidence

The new gix-diff crate provides optimized algorithms for diffing Git objects, exposing public APIs to diff trees, indices, and blobs. A key behavioral addition is the \Rewrites\ configuration structure, which allows users to control rename and copy tracking sensitivity via similarity percentages, limits, and a new \track\_empty\ flag to exclude empty files from identity detection. Blob diffing is now gated behind the \blob\ feature flag (enabled by default), allowing users to disable it if not needed, while the library re-exports necessary dependencies like \gix\_command\ and \gix\_object\ only when that feature is active.

gix-diff/src · high confidence

The new \gix-dir\ crate provides a Git-style directory walk capability, exposing an API to traverse worktrees and inspect entries. Users can now retrieve directory entries with detailed status information (tracked, ignored, untracked, or pruned), disk kinds (file, directory, symlink, or untrackable special files), and pathspec match details. The implementation handles complex scenarios such as submodule worktrees, empty directories, and the \.git\ directory, ensuring that non-file system objects like FIFOs are correctly identified as untrackable and pruned from standard views.

gix-dir/src · high confidence

The new gix-error crate provides a unified error handling system that replaces thiserror in several gix components. It introduces structured error classification (Validation, Corruption, NotFound, Retryable, ResourceExhaustion, Io) allowing callers to programmatically inspect error semantics via methods like is\_retryable() and is\_validation(). The crate supports anyhow integration through an auto-chain-error feature, enabling seamless error chain display. It also includes location tracking for diagnostic purposes and a TestResult type for improved test error reporting.

gix-error/src · high confidence

The new \gix-fs\ crate consolidates filesystem utilities, introducing \Capabilities\ to automatically probe and expose filesystem properties such as case-sensitivity, symlink support, executable-bit handling, and Unicode precomposition. It provides \adjust\_shared\_repository\_permissions\ to apply Git's shared-repository permission policies to new files and directories, \FileSnapshot\ for tracking resource modification times, and \ToNormalPathComponents\ for validating and iterating path components.

gix-fs/src · high confidence

The new gix-glob crate provides a \Pattern\ type for matching paths against glob patterns, optimized for repository-relative path matching. It includes utilities for searching matches of paths to patterns, specifically designed for how both excludes and attributes are searched, and shares code among them. The crate also adds benchmarks for wildmatch performance.

gix-glob · high confidence

The new gix-hashtable crate provides a HashMap and HashSet implementation optimized for Git object IDs by using a custom hasher that extracts the first 8 bytes of the hash, avoiding redundant hashing. It also includes a thread-safe ObjectIdMap that uses sharding (256 shards based on the first byte of the object ID) with parking\_lot mutexes to allow concurrent access, scaling well up to 256 threads.

gix-hashtable · high confidence

The new gix-ignore crate provides utilities to parse .gitignore files and match paths against them, extracted from gix-attributes. It introduces an experimental 'precious' file feature: when enabled, patterns prefixed with $ mark files as precious, meaning they are ignored but kept (treated like untracked files) rather than removed. The crate includes a fuzz target with sanitization to prevent pathological glob patterns from dominating execution time, and adds corpus files for testing slash, star, and precious file scenarios.

gix-ignore · high confidence

The gix-lock crate provides a mechanism for creating atomic, git-style lock files to safely update resources. It introduces \File\ and \Marker\ types that allow applications to acquire locks with configurable failure modes (immediate failure or retry with backoff), write content to temporary lock files, and atomically commit them to overwrite the target resource. The implementation supports shared repository permissions, automatic cleanup of intermediate directories, and symlink resolution, ensuring that resource updates are safe and consistent even in concurrent environments.

gix-lock · high confidence

The new \gix-macros\ crate provides four procedural macros to aid in shared blocking/async implementations and performance optimization. The \sync\ macro transforms async Rust code into its blocking equivalent by stripping \async\ and \.await\ tokens. The \keep\ and \discard\ macros allow conditional compilation of code paths for blocking versus async variants. The \momo\ macro reduces binary size by wrapping functions to call a single de-monomorphized implementation (using \&dyn Trait\) for arguments bounded by \Into\, \AsRef\, or \AsMut\, thereby minimizing landing-pad code.

gix-macros · high confidence

The new \gix-note\ crate provides a Rust implementation for reading and mutating Git notes trees. It supports lazy note lookups by loading only the necessary fanout subtrees and caching them in a caller-owned state, which improves performance for bulk queries. The crate also enables note mutation (insert, replace, remove) with batched edits that are written in a single tree write operation, maintaining compatibility with Git's progressive fanout heuristic and preserving unrelated entries.

gix-note · high confidence

The new gix-prompt crate provides a unified interface for interactive user input, supporting both direct terminal prompts and external askpass programs (via the askpass option or GIT\_ASKPASS/SSH\_ASKPASS environment variables). It exposes openly() and securely() helpers for visible and hidden input respectively, and allows configuring the prompt mode (Visible, Hidden, or Disable) and specifying a custom askpass executable path. On Unix systems, it manages terminal state to hide input when needed, while non-Unix platforms return an error indicating no terminal implementation is available.

gix-prompt · high confidence

The new gix-quote crate provides functions to quote and unquote strings using Git-compatible rules. It includes ansi\_c::quote() and ansi\_c::undo() for C-style quoting (handling escapes like \\n, \\t, and octal sequences) and single() for Bourne shell single-quote escaping. A key behavioral change is that unclosed quotes in ansi\_c::undo() now return an error instead of panicking or silently failing.

gix-quote · high confidence

The new \gix-shallow\ crate provides functionality to read and write the \.git/shallow\ file, which defines the shallow boundary of a repository. It exposes \read()\ to retrieve a list of shallow commit IDs and \write()\ to apply updates (adding or removing specific commits) to that list, handling file locking and cleanup when the list becomes empty.

gix-shallow · high confidence

Adds the gix-tix crate, a minimal, tig-inspired commit-history browser optimized for large repositories. It provides a TUI for browsing and editing commit history, alongside a non-interactive 'tix show' command for plain-text history projection. The tool supports time travel, commit rewording, splitting, squashing, and cherry-picking, while maintaining memory efficiency and responsiveness on large histories.

gix-tix · high confidence

The new gix-trace crate provides a minimal tracing API that integrates with the \tracing\ ecosystem when the \tracing\ feature is enabled, allowing users to create spans and emit events (e.g., \warn!()\) with coarse or detail levels. When the feature is disabled, it provides no-op implementations to avoid runtime overhead. The crate also exposes macros for recording values to spans and supports entering scopes via \into\_scope()\.

gix-trace · high confidence

The new gix-utils crate provides a collection of utilities for string normalization, buffer management, and retry backoff. It introduces \str::precompose()\ and \str::precompose\_path()\ to handle Unicode NFC normalization while preserving combining mark order and handling non-BMP characters, alongside \str::decompose()\. The crate also adds \AsBStr\ and \AsBStrOpt\ traits for zero-allocation byte-string conversions, a \Buffers\ type for efficient source/destination swapping, a \Quadratic\ backoff iterator for randomized retry delays, and a \btoi\ module for parsing integers from byte slices.

gix-utils · high confidence

The new gix-validate crate provides strict validation for Git reference names (branches, tags), submodule names, and path components. It enforces Git's naming rules, rejecting invalid characters, reserved names, and structural issues like empty components or trailing slashes. Additionally, it includes platform-specific protections for Windows (e.g., blocking device names like CON or NUL) and macOS (HFS+), ensuring that file paths cannot escape the repository or trigger unintended system behaviors.

gix-validate · high confidence

The \gix-worktree-stream\ crate has been created to provide a streaming interface for worktree entries, extracted from the previous \gix-archive\ functionality. It exposes a \Stream\ type that allows consumers to iterate over entries (blobs and symlinks) from a git tree on demand, supporting background traversal and filtering via \gix-filter\. The \Stream::add\_entry\_from\_path\ API has changed to accept a \hash\_kind\ argument, enabling support for different hash algorithms (such as SHA-256) in test fixtures and production use.

gix-worktree-stream · high confidence

The \gix-zlib\ crate has been introduced to provide streaming compression and decompression utilities, consolidating the previous \zlib\ module into a dedicated package. This change makes zlib compression levels configurable via a new \Compression\ type, allowing callers to explicitly choose levels from 0 (no compression) to 9 (best compression) when creating deflate streams. The crate exposes \Decompress\ and \Inflate\ types for stateful and single-step decompression, as well as streaming adapters in the \stream\ module, and migrates error handling to use \gix-error\ for consistent diagnostics.

gix-zlib · high confidence

The \gix-config\ crate now exposes a new \file::mutable\ module providing \SectionMut\ and \ValueMut\ types that allow users to modify in-memory configuration data. This includes capabilities to rename sections, push or set key-value pairs (with optional comments), remove entries, and manage multi-value keys, enabling the construction and modification of configuration files before writing them to disk.

gix-config/src/file/mutable · high confidence

The \gix-config\ module now provides a new, high-level \File\ API for reading and mutating configuration files. Users can create \File\ instances directly from strings or byte slices using \TryFrom\ and \FromStr\ implementations, which parse the content into a lifetime-free, owned structure. The module introduces a \Metadata\ struct to track file source, path, and security trust levels, allowing the library to distinguish between API-provided configurations and files loaded from disk. Additionally, the new implementation includes robust section lookup acceleration and ensures that serialization preserves the original file's newline style and structure.

gix-config/src/file · high confidence

The \gitoxide-core/src/repository\ directory now includes dedicated modules for implementing core git operations, including \archive\, \blame\, \branch\, \cat\, \clean\, \clone\, \commit\, \config\, \credential\, \diff\, \dirty\, \dirwalk\, \editor\, \exclude\, and \fetch\. These modules provide the underlying logic for corresponding CLI subcommands, enabling users to create archives, view file history, manage branches, inspect objects, clean the working directory, clone repositories, sign and describe commits, manage configuration, handle credentials, compare files and trees, check repository status, walk the directory tree, launch editors, query exclusion patterns, and fetch from remotes.

gitoxide-core/src/repository · high confidence

The \gix\ library now exposes a detailed \Outcome\ structure from the fetch ref-update process, allowing users to inspect exactly how each reference mapping was handled. This includes specific modes such as \FastForward\, \Forced\, \New\, \RejectedTagUpdate\, and \RejectedCurrentlyCheckedOut\, along with associated reflog messages and edit details. This change provides granular feedback on fetch results, enabling applications to handle specific scenarios like non-fast-forward rejections or tag overwrites more precisely than before.

_gix/src/remote/connection/fetch/update\refs · high confidence

The \gix-merge\ crate now implements built-in \text\ and \binary\ merge algorithms, allowing the library to automatically resolve or flag conflicts in file content during merges. The text driver supports multiple conflict styles (\Merge\, \Diff3\, \ZealousDiff3\) and allows re-running merges with different conflict resolutions via a prepared state, while the binary driver provides logic for auto-resolving conflicts by picking a side. This change also fixes several tree-merge behaviors, including treating adjacent text changes as conflicting, correctly handling additions below jointly deleted files, and ensuring tree changes are tracked as applied rather than just processed.

gix-merge · high confidence

The \gix-negotiate\ crate now includes a new \consecutive\ negotiation algorithm, implemented in \src/consecutive.rs\. This algorithm uses a priority queue to traverse the commit graph and determine which objects are in common with a remote, providing an alternative to the existing \skipping\ and \noop\ negotiators for optimizing pack data transfer.

gix-negotiate · high confidence

The monolithic gitoxide binary has been split into a dedicated 'gix' CLI located in src/plumbing. This new entry point provides a comprehensive set of subcommands for repository operations (such as clone, fetch, status, blame, and diff), low-level plumbing tasks (like index, pack, and odb management), and configuration introspection (config tree and list). It supports command-line configuration overrides via -c, thread limiting, and various output formats, serving as the primary user-facing interface for Git operations in this project.

src/plumbing · high confidence

The \gix-diff\ crate now provides plumbing facilities to track file renames and copies during tree diffs. This change introduces the \tree\_with\_rewrites\ module, which exposes \Change\ and \ChangeRef\ enums to represent additions, deletions, modifications, and rewrites (renames/copies). The new \diff\ function in \function.rs\ allows users to traverse tree changes with optional rename tracking, utilizing a resource cache for efficiency and returning an \Outcome\ when rewrites are detected. This enables consumers to distinguish between simple modifications and structural changes like renames or copies.

_gix-diff/src/tree\_with\rewrites · high confidence

Added several new command-line examples in the \gix/examples\ directory to demonstrate core library capabilities. The \clone\ example shows how to clone a repository from a URL or path, including interrupt handling and remote configuration. The \init-repo-and-commit\ example demonstrates initializing a bare repository and creating commits with tree structures. The \stats\ example provides a way to analyze a repository's commit history, tree structure, and reference integrity. Additionally, \interrupt-handler-allows-graceful-shutdown\ and \reversible-interrupt-handlers\ illustrate the new interrupt feature for graceful signal handling, while \gix-notes-bench\ offers a benchmark for creating and packing Git notes.

gix/examples · high confidence

The \gix\ crate introduces a new \Connection\ builder in \gix/src/remote/connection\ that allows users to configure custom credentials and transport options before establishing a remote connection. This includes methods like \with\_credentials\ and \set\_credentials\ to provide custom authentication callbacks, and \with\_transport\_options\ for custom backend configuration. Additionally, the \Connection::ref\_map()\ method enables fetching a list of remote references filtered by the remote's fetch refspecs, supporting options for remote prefix filtering and custom handshake parameters, without fetching the actual objects or modifying the local repository.

gix/src/remote/connection · high confidence

Added a new Alpine-based Dockerfile for building and running gitoxide binaries, including a minimal scratch image variant. Introduced a Dockerfile and configuration for cross-compilation testing via the \cross\ tool, specifically targeting \armv7-linux-androideabi\ and \s390x-unknown-linux-gnu\ architectures with custom environment passthrough and image handling.

etc/docker · high confidence

The \gix/src/head\ module has been restructured to provide a more comprehensive API for interacting with the HEAD reference. Users can now inspect the state of HEAD (symbolic, unborn, or detached) via the new \Kind\ enum and methods like \is\_detached()\ and \is\_unborn()\. The module introduces robust peeling capabilities, allowing users to resolve symbolic references and tags to their final target objects or IDs using methods such as \peel\_to\_object()\, \peel\_to\_commit()\, and \into\_peeled\_id()\, with previous in-place variants marked as deprecated. Additionally, a new \log\ submodule exposes \log\_iter()\ and \prior\_checked\_out\_branches()\ to access the HEAD reflog, enabling users to retrieve history of previously checked-out branches and their associated commit IDs.

gix/src/head · high confidence

The \gix::Repository\ API now includes dedicated modules for managing git attributes and excludes (\attributes\, \excludes\), performing file blame analysis (\blame\_file\), deleting local branches with configuration cleanup (\delete\_local\_branches\), and computing diffs between trees (\diff\_tree\_to\_tree\). These additions provide more granular control over repository state and history analysis, aligning closer to standard git workflows while introducing new error types for branch deletion conflicts.

gix/src/repository · high confidence

The \gix/src/submodule\ module introduces a comprehensive API for managing Git submodules, including the \Submodule\ type to represent declared submodules and methods to query their configuration (name, path, URL, branch, update strategy, etc.). A key addition is the \Submodule::status()\ method, which provides detailed status information by comparing the index and HEAD states, handling cases where submodules are added or deleted but not yet committed. The module also includes logic to follow submodule gitdir files, validate submodule names, and ensure status operations respect worktree availability and configuration settings like \status.showUntrackedFiles\.

gix/src/submodule · high confidence

The repository's attribute handling now exposes two new core functions: \query\, which retrieves attribute matches for specific paths or patterns (supporting both direct paths and pathspecs), and \validate\_baseline\, which compares the repository's attribute and ignore state against the standard Git implementation to ensure compatibility. These additions allow users to programmatically inspect attribute assignments and verify that gitoxide's attribute resolution matches the baseline behavior of \git check-attr\ and \git check-ignore\.

gitoxide-core/src/repository/attributes · high confidence

The \gix-attributes\ crate now uses a new search module that exposes whether a matched pattern corresponds to a directory via the \is\_dir\ parameter in \pattern\_matching\_relative\_path\. The search engine supports attribute macros, allowing patterns to resolve into sets of other attributes, and provides an API to optionally disable macro processing via the \allow\_macros\ flag. Results are returned through an \Outcome\ struct that tracks matches by unique IDs, supports selecting specific attributes to search for, and includes location metadata (source file and line number) for each match.

gix-attributes/src/search · high confidence

The \gix-diff\ crate introduces a new \blob\ module that replaces the previous diffing implementation with a more robust platform. This change adds support for Git's slider heuristics (via \imara-diff\) to produce more intuitive and readable diffs. It also introduces a \Pipeline\ and \Platform\ system that handles content conversion, caching, and integration with \git-attributes\ drivers, including support for external text-conv filters and binary-to-text commands. Users will see improved diff quality and better handling of complex file types and filters.

gix-diff/src/blob · high confidence

The clone workflow now exposes \PrepareFetch\ and \PrepareCheckout\ builders, allowing users to configure the remote, specify shallow depth, override in-memory configuration, and select which reference or revision to check out before the operation completes. This replaces the previous implicit behavior with explicit control over fetch options and checkout targets, including support for detached HEAD checkouts via specific revisions.

gix/src/clone · high confidence

The \gix-chunk\ crate now includes a complete implementation for reading and writing chunked files. Users can decode existing chunk file indices from binary data, validating structure and offsets, and retrieve specific chunk data by ID. Additionally, a new writing API allows users to plan chunks and write them to an output stream, automatically generating the table of contents and sentinel values required by the format.

gix-chunk/src/file · high confidence

Added two new standalone example applications, \log.rs\ and \ls-tree.rs\, that demonstrate fully-fledged command-line tools using the \gix\ library. The \log\ example implements a \git log\-like interface with support for sorting, filtering by parent count (merges), path history, and reversing output, while the \ls-tree\ example implements a \git ls-tree\-like interface with recursive traversal and filtering options for trees and files.

examples · high confidence

Users can now list commits using the commit-graph cache and verify its integrity. The new \list\ function supports range queries (from..to) with hidden commit filtering and outputs human-readable details including commit hashes, timestamps, parent counts, and graph cache status. The \verify\ function checks commit-graph integrity and outputs statistics about parent distribution and longest path length, with optional JSON output when the serde feature is enabled.

gitoxide-core/src/repository/commitgraph · high confidence

The configuration tree now includes formal definitions for numerous Git configuration sections, allowing users to read and validate settings such as \author.name\, \branch.\<name\>.merge\, \core.abbrev\, \http.sslVerify\, \gpg.format\, and \index.threads\. These new section files define the keys, their types, validation rules, and environment variable overrides (e.g., \GIT\_AUTHOR\_NAME\ for \author.name\), ensuring that configuration values are correctly parsed and enforced according to Git-compatible standards.

gix/src/config/tree/sections · high confidence

The \gix-config\ crate now provides a new \init\ module with high-level convenience methods to instantiate configuration files. Users can load global, system, and installation-level configs via \File::from\_globals()\, read environment variable overrides with \File::from\_environment\_overrides()\, or assemble a complete repository configuration (including local, worktree, and global sources) using \File::from\_git\_dir()\. These methods handle path resolution, trust verification, and include directive resolution automatically. The module also exposes \Options\ to control behavior, such as ignoring IO errors when reading missing files or using a lossy parsing mode to reduce memory usage by discarding comments and whitespace.

gix-config/src/file/init · high confidence

The \gix-credentials\ helper module now provides a structured \Cascade\ and \invoke\ API for managing credential helpers. Users can configure a list of helper programs (with platform-specific defaults like \osxkeychain\, \libsecret\, or \manager-core\) and control behavior via options such as \use\_http\_path\ (to include URL paths in credential lookups) and \query\_user\_only\ (to fetch only the username). The new \invoke\ function handles the execution of these helpers, parsing their output into a \Context\ and returning an \Outcome\ containing the username, password, and optional OAuth refresh token. This replaces the previous direct invocation logic with a more configurable and robust cascade system.

gix-credentials/src/helper · high confidence

The \gix-credentials\ library introduces a new \protocol\ module that defines the core data structures for credential operations. Users will now interact with \Context\ to provide detailed authentication details, including protocol, host, path, username, password, OAuth refresh tokens, and HTTP WWW-Authenticate challenges. The \ContextOptions\ struct allows configuration of protocol protection settings. The module also defines \Outcome\ to represent the result of credential helper invocations, containing the obtained identity and the next action to take. This change establishes the foundational types for credential handling within the \gix-credentials\ crate.

gix-credentials/src/protocol · high confidence

The \gix-fs\ crate introduces new directory management capabilities in \src/dir\. Directory creation (\create.rs\) now applies Git's shared repository permissions to newly created directories and distinguishes between a path collision (where a component exists but is not a directory) and a directory that already exists, returning a specific \NotADirectory\ error for the former. Directory removal (\remove.rs\) provides utilities to delete empty directories upward to a boundary or perform a depth-first removal of empty directories, ensuring that non-empty directories abort the operation.

gix-fs/src/dir · high confidence

The \gix/src/ext\ module introduces extension traits (\ObjectIdExt\, \ReferenceExt\, \TreeEntryExt\, \TreeEntryRefExt\, \TreeIterExt\, and \RevSpecExt\ behind the \revision\ feature) that allow users to attach a \Repository\ instance to various core types like object IDs, references, and tree entries. This enables these detached types to carry repository context for subsequent operations, while also providing a \traverse\ method on tree iterators for breadth-first traversal.

gix/src/ext · high confidence

The fetch subsystem now exposes configuration options for pack index version and thread count, allowing users to tune performance via git-config. Additionally, the fetch outcome now includes detailed negotiation information, enabling users to understand the steps taken during the fetch process.

gix/src/remote/connection/fetch · high confidence

The \gix-features\ crate now exposes several new modules that provide core utilities for other \git-\*\ components. Users can now leverage \cache\ for debug-enabled cache efficiency tracking, \decode\ for safe LEB64 variable integer decoding, and \fs\ for filesystem operations including \walkdir\ and \read\_dir\ with optional Unicode precomposition support. The \hash\ module adds CRC32 computation, while \interrupt\ provides wrappers for \Read\/\Write\ and \Iterator\ to support cancellation via atomic flags. Additionally, \io\ introduces a unidirectional byte pipe, \progress\ offers \prodash\-based progress tracking with byte and human-readable units, and \threading\ abstracts thread-safe primitives (like \Arc\/\Mutex\ vs \Rc\/\RefCell\) based on the \parallel\ feature toggle.

gix-features/src · high confidence

The \gix-credentials/src/program\ module introduces the infrastructure for launching and managing external credential helpers. It defines the \Action\ enum (Get, Store, Erase) and a \main\ function that parses command-line arguments and stdin context to invoke user-provided credential callbacks. The module also handles the construction of \std::process::Command\ objects for various helper types (builtin Git, external names, absolute paths, and shell scripts), ensuring proper shell quoting for paths with spaces and managing standard I/O streams for communication with the helper process.

gix-credentials/src/program · high confidence

The \tests/tools\ directory now contains the \gix-testtools\ crate, providing a comprehensive suite of utilities for testing gitoxide and git-based applications. This includes a CLI tool (\jtt\) with subcommands for managing git daemons, inspecting bash paths, and generating CycloneDX/SPDX Software Bill of Materials (SBOMs). The library offers robust fixture management with support for scripted and Rust-based read-only/writable fixtures, automatic archive generation, and isolation of git configuration to prevent interference from user settings. It also introduces stable repository state snapshots (via \gix\ or \git\ backends), portable snapshotting for cross-platform testing, and dedicated helpers for testing Git signatures using isolated, passwordless SSH, OpenPGP, and X.509 test identities.

tests/tools · high confidence

Users can now inspect and validate the repository index using new CLI capabilities. The \gix index verify\ command checks the integrity of the index file, including its entries and extensions, and reports success or specific errors. Additionally, \gix index information\ provides a detailed JSON report of the index contents, including entry counts by stage and mode, extension names (with optional detailed tree extension data), and version information. These commands operate on the index file directly, allowing users to diagnose index corruption or understand its structure without performing a full checkout.

gitoxide-core/src/index · high confidence

The \gix-commitgraph\ crate now exposes a structured API for reading and validating commit-graph files through the new \file\ module. Users can open graph files via \File::at\ or \File::new\, access individual commits and their metadata (such as timestamps, generation numbers, and parent edges) through \File::commit\_at\ and \Commit\, and iterate over all commits or object IDs. The API also includes \File::traverse\ for verifying file integrity, including checksum validation and structural consistency checks, ensuring that the graph data is valid before processing.

gix-commitgraph/src/file · high confidence

The repository now exposes dedicated merge operations for trees, commits, and individual files. Users can merge two trees to produce a resulting tree (with optional commit creation via \--message\ and \--update-head\), merge two commits to produce a merged tree, and merge specific file contents using base/ours/theirs inputs. These operations support options for output formatting, file/tree favor strategies, in-memory processing, and debug output, enabling more granular control over merge resolution within the repository.

gitoxide-core/src/repository/merge · high confidence

Users can now detach objects from their repository context using \detach()\ and \detached()\ methods on all object types, and extract raw data with \take\_data()\. The \Object\ type gains safe conversion methods like \try\_into\_blob()\ and \try\_into\_tag()\, alongside peeling capabilities (\peel\_to\_commit()\, \peel\_to\_tree()\) to resolve tags and commits. Additionally, the \blob-diff\ feature enables line-level diffing and line-count statistics for blobs via the new \Platform\ interface.

gix/src/object · high confidence

The \gitoxide-core\ pack module now exposes a comprehensive set of operations for managing Git packfiles. Users can create new packs from repository tips or input streams with configurable object expansion, thread limits, and cache sizes (\create\). Existing packs can be unpacked into loose objects or a sink with configurable safety checks and compression (\explode\). Indexes can be generated from packs (\index\), and both single and multi-pack indexes can be verified for integrity using optimized algorithms (\verify\, \multi\_index\). Additionally, packs can be received from remote repositories via the Git protocol, supporting both async and blocking transports (\receive\).

gitoxide-core/src/pack · high confidence

The \gix-features/src/parallel\ module introduces new concurrency utilities to improve parallel processing flexibility and correctness. \EagerIter\ and \EagerIterIf\ allow iterators to be evaluated in background threads with configurable chunking and back-pressure, while \InOrderIter\ enables collecting results from parallel workers and reassembling them in their original sequence order. Additionally, \in\_parallel\_with\_finalize\ extends the standard \in\_parallel\ API by allowing a per-thread \finalize\ step to process remaining state before aggregation, and the module now uses \std::thread::scope\ for safer thread lifecycle management.

gix-features/src/parallel · high confidence

The gix-path crate introduces several new capabilities for path manipulation and environment discovery. It adds \env::installation\_program()\ to locate programs bundled with Git (particularly useful on Git for Windows where tools may reside in bin or usr/bin rather than the standard exec-path), and \env::shell\_command()\ to obtain the shell Git would use. Path normalization is enhanced with \normalize\_and\_clean()\ for full normalization, \normalize\_saturating()\ for safe saturation, and \relativize\_with\_prefix()\. Conversion utilities are expanded with \try\_os\_str\_into\_bstr()\ accepting \Cow\<OsStr\>\, and \join\_bstr\_unix\_pathsep()\ for joining paths with Unix separators. The crate also adds \env::core\_dir()\ to retrieve the Git core directory and \env::executable\_invocation()\ to determine how to invoke Git.

gix-path · high confidence

The \gix::reference\ module now provides a comprehensive API for managing and inspecting Git references. Users can iterate over references using a new \Platform\ that supports filtering by prefix, tags, local/remote branches, and pseudo-references (like HEAD), with an option to automatically peel symbolic refs and tags during iteration. The \Reference\ type now includes methods to set target IDs, delete references with optimistic locking, and peel references to specific object kinds (commits, tags, trees) or fully peeled IDs, utilizing packed buffers for performance. Additionally, remote tracking information is accessible directly from references, allowing users to resolve remote names, remote objects, and upstream ref names for both local branches and remote-tracking branches.

gix/src/reference · high confidence

The \gix-diff\ crate now includes a dedicated \rewrites\ module that tracks file renames, copies, and rewrites. This new subsystem introduces a \Tracker\ to manage change state, supports configurable copy sources (modified files only or including all source files), and enforces rename limits (\renamelimit\) and similarity thresholds. It also provides detailed outcome statistics, such as the number of similarity checks performed and skipped, and integrates with the blob diff platform for optimized content comparison.

gix-diff/src/rewrites · high confidence

The repository configuration module has been reorganized into dedicated submodules (branch, remote, transport, and general config), exposing a comprehensive set of methods to query and manage repository settings. Users can now retrieve branch names and their upstream tracking information via \branch\_names\, \branch\_remote\_ref\_name\, and \branch\_remote\_tracking\_ref\_name\, with support for both fetch and push directions. Remote management is enhanced with \remote\_names\ and \remote\_default\_name\ to identify configured remotes and determine the default target for operations. Transport configuration is now accessible through \transport\_options\, which resolves HTTP, HTTPS, proxy, and SSL settings from the repository's configuration to pass to transport clients. Additionally, general configuration access includes \config\_snapshot\, \config\_path\, \config\_file\_mut\ for atomic edits, \editor\ for Git-compatible editor selection, and \commit\_signing\_options\ for GPG signing setup.

gix/src/repository/config · high confidence

Users can now use new revision-related commands to inspect and traverse repository history. The \explain\ command breaks down revision specifications into human-readable steps (e.g., reference lookups, disambiguation, reflog queries, and traversal). The \list\ command iterates over commits matching a spec, supporting text output and SVG graph generation. The \previous-branches\ command lists previously checked-out branches based on the HEAD reflog. The \resolve\ command resolves revision specs, with options to explain the resolution, cat file contents, control tree/blob formatting, and show references.

gitoxide-core/src/repository/revision · high confidence

The \gix/src/revision\ module introduces a new public API for traversing commit graphs, accessible via \Repository::rev\_walk()\. This feature allows users to walk revisions with configurable sorting (breadth-first or by commit time) and automatically leverages the commit-graph data structure for performance, which can be explicitly enabled or disabled via \Platform::use\_commit\_graph()\. The API yields \revision::Info\ structs containing commit IDs, parent IDs, and generation numbers, replacing the previous behavior of yielding raw IDs.

gix/src/revision · high confidence

The \gix\ status module has been restructured to provide a builder-based \Repository::status()\ API that returns a \Platform\ for configuring and iterating over repository status. This new interface supports lazy, thread-local evaluation, allows configuring untracked file display modes (collapsed, files, or none), and enables rename tracking between the index and worktree. It also introduces explicit support for querying submodule status via \Submodule::status()\ and \Repository::is\_dirty()\, which now checks both index/worktree changes and tree/index differences. The API respects the \status.showUntrackedFiles\ configuration and provides options for interrupting long-running status checks.

gix/src/status · high confidence

The \gix\ library introduces a new \status::Platform::into\_iter()\ method that provides a complete status iterator, replacing previous single-operation status calls. This new API supports parallel execution (when the \parallel\ feature is enabled), running directory walks, index-to-worktree checks, and tree-to-index comparisons concurrently to improve performance. It also adds support for interrupting long-running status checks via \should\_interrupt\ flags and allows consumers to write back index changes detected during the iteration using \Outcome::write\_changes()\. The iterator yields items for both index-worktree and tree-index changes, though ordering is not guaranteed in parallel mode.

gix/src/status/iter · high confidence

The \gix-config\ crate now exposes a new \file::access\ module that organizes configuration retrieval and mutation into four distinct layers: \comfort\ (high-level typed getters like \string\, \path\, \boolean\, and \integer\), \mutate\ (methods for creating, renaming, and modifying sections), \raw\ (low-level uninterpreted byte-string access), and \read\_only\ (generic interpreted value retrieval). This change provides users with a more ergonomic and type-safe way to interact with configuration files, separating simple lookups from complex mutations and raw data access.

gix-config/src/file/access · high confidence

The \gix\ crate now exposes a new \config::tree\ module that provides a structured, type-safe registry of Git configuration keys. This change introduces traits (\Section\, \Key\) and a \Tree\ root that enumerates all supported configuration sections (such as \core\, \remote\, \fetch\, \push\, etc.), allowing users to validate configuration values before applying them as overrides or to discover available keys programmatically. This replaces the previous ad-hoc handling with a centralized, extensible system for configuration metadata and validation.

gix/src/config/tree · high confidence

The \gix\ library now exposes a dedicated tree-diffing API under \object::tree::diff\, providing \Tree::changes()\ to generate a \Platform\ for iterating over additions, deletions, modifications, and renames (rewrites) between two trees. This platform supports optional resource caching for efficient line-level diffs via \Change::diff()\ and offers a \stats()\ method to quickly calculate lines added, removed, and files changed, mirroring the functionality of \git2\'s \diff\_tree\_to\_tree\.

gix/src/object/tree/diff · high confidence

The \gix-diff\ crate now exposes a new \tree()\ function in \gix-diff/src/tree\ to compute changes between two Git trees. This change introduces a visitor-based architecture (\Visit\ trait) that allows consumers to process additions, deletions, and modifications as they are discovered during a breadth-first traversal. A key feature is the \Recorder\ delegate, which now supports configurable location tracking via \track\_location()\, allowing users to choose between recording the full relative path or just the filename for each change, optimizing for performance when full paths are not needed. The API also supports early termination of the traversal via \std::ops::ControlFlow::Break\.

gix-diff/src/tree · high confidence

Users can now modify Git trees in memory using the new \Tree::edit()\ API, which provides an \Editor\ for inserting, updating, and removing entries, along with a \Cursor\ for navigating and editing specific sub-trees. The \Tree\ type also gains traversal methods (\traverse().breadthfirst()\ and \traverse().depthfirst()\) for recursively walking tree structures, and convenient lookup methods like \find\_entry()\ and \lookup\_entry\_by\_path()\ to locate entries by name or path.

gix/src/object/tree · high confidence

The \gix-config\ parser has been rewritten to eliminate heap allocations during parsing by storing all string data in a shared backing buffer and using zero-copy spans. This change introduces a new event-based API (\Events\, \EventRef\) that allows iterating over syntactic tokens without copying, and adds a \parse::format\ module to normalize git-config whitespace (indentation, newlines, spacing around \=\) while preserving the original file's content. Error reporting has also been updated to include specific line numbers and the unparsed data that caused the failure.

gix-config/src/parse · high confidence

The library now supports parsing Git objects using the SHA-256 hash algorithm, in addition to the traditional SHA-1. This enables compatibility with repositories or servers that utilize the SHA-256 object format, allowing users to interact with such repositories without format-parsing errors.

(repo-wide) · high confidence

The \gix-error\ library now provides a structured error system that allows users to attach semantic classifications (such as validation failures, not-found errors, or retryable conditions) and named diagnostic metadata (like integers, strings, or paths) to error contexts. This change introduces \Message\ for visible diagnostics with optional classes, \ClassificationMarker\ for transparent metadata that doesn't alter the error's diagnostic output, and \ChainedError\ to flatten error trees for better compatibility with \anyhow\ and standard error source chains. Users can now inspect error causes more precisely using classification predicates and access structured metadata for better debugging and error reporting.

gix-error/src/concrete · high confidence

The configuration parser now supports the \hasconfig:remotes.\*.url:\<url-glob\>\ condition in \includeIf\ directives, allowing configuration files to be included based on whether existing remote URLs match a specified glob pattern. This enables dynamic configuration loading that reacts to the presence and values of remote definitions within the repository.

gix-config/src/file/includes · high confidence

The \gix-filter\ driver now supports communicating with long-running external filter processes via a new packet-line protocol. This introduces a handshake mechanism where the client and server negotiate a protocol version and a set of capabilities, allowing for more robust and extensible filter interactions. The implementation includes new \Client\ and \Server\ structs to manage the process lifecycle, handle command invocations with metadata, and parse status responses (such as success, delay, or abort), enabling features like graceful shutdowns and delayed output processing.

gix-filter/src/driver/process · high confidence

The remote URL handling now supports configuring which network protocols are allowed via the \protocol.allow\ and \protocol.\<scheme\>.allow\ configuration keys, as well as the \GIT\_PROTOCOL\_FROM\_USER\ environment variable, enabling stricter control over remote helpers and extension commands. Additionally, the \url.\<base\>.insteadOf\ and \url.\<base\>.pushInsteadOf\ configuration options are now processed to rewrite fetch and push URLs based on the longest matching prefix.

gix/src/remote/url · high confidence

The \gix-worktree\ crate now supports opt-in validation to reject terminal symlinks (non-directory components) on Windows. This allows callers to prevent following symlinks during path traversal while reusing the stack's component-by-component logic, improving security on platforms where symlink following is a risk. Additionally, the crate removes the now-unnecessary \symlink\ dependency in favor of \gix-fs\.

gix-worktree · high confidence

The gix-error crate has been updated to version 0.3.2, introducing more ergonomic tools for writing tests. Test functions now only require the Debug trait for their error types, allowing TestError to accept both standard errors and Exn without relying on boxed errors as the public result type. Additionally, direct, asymmetric comparisons with string slices and owned strings are now supported, keeping assertions concise while retaining Display semantics.

gix-error · high confidence

This release introduces \entry::Mode::change\_to\_match\_fs\_with\_values()\, which provides fine-grained control over input to avoid forcing native \gix\_index::fs::Metadata\. It also includes general code improvements and updates to the project's changelog and documentation.

gix-index · high confidence

The gix-pack crate now exposes index-less parallel pack traversal, allowing external callers to build a delta Tree directly from a pack header scan and resolve objects in parallel without a pre-built .idx file. Additionally, delta tree resolution has been made lazy using a lock-free pool, which significantly reduces peak memory usage and improves multi-threaded performance on large packs.

gix-pack · high confidence

The gix-tui crate now includes a stub main entry point that explicitly forbids unsafe code and marks the functionality as unimplemented, alongside the addition of symlinks to the project's Apache-2.0 and MIT license files.

gix-tui · high confidence

The git-daemon request serializer now rejects NUL, CR, and LF characters in repository paths and virtual hosts before any data is written. This prevents potential injection or parsing issues by validating inputs early, aligning with git's own security practices for host and path components.

gix-transport · high confidence

The \arrow.rs\ example in \gix-filter/examples\ has been replaced with a file that includes the shared test helper implementation from \../tests/helpers/arrow.rs\. This change ensures the example maintains a consistent interface with other workspace tests while reusing the existing helper logic, rather than containing its own independent implementation.

gix-filter/examples · high confidence

New scripts in \etc/scripts\ enforce stricter build constraints for the gix workspace. \cargo-check-all.sh\ and related helpers verify that hash features (sha1/sha256) are explicitly required or correctly combined, prevent hash algorithms from being default features, and ensure hash-independent crates do not accidentally depend on them. \check-package-size.sh\ uses \cargo diet\ to enforce size limits on individual crates, while \ci-check-local.sh\ provides a local CI simulation that includes these checks alongside formatting, clippy, and test runs.

etc/scripts · high confidence

The \gix-date\ parser now matches Git's handling of relative dates by rolling over month ends (e.g., one month before May 31st becomes May 1st) instead of clamping, and accepts the \@\ prefix for epoch seconds to resolve ambiguity with compact dates. It also rejects timezone offsets wider than ±23:59 and rejects bare numeric dates smaller than 100,000,000 as ambiguous. Additionally, the \parse()\ function now returns timezone-aware instants when using the \now\ parameter, and supports case-insensitive relative date units.

gix-date/src/parse · high confidence

The gix-tempfile crate now handles Windows-specific file locking issues during persist operations by implementing a retry mechanism (up to 10 attempts with 5ms delays) to overcome temporary access denied or sharing violation errors caused by external processes like antivirus software. Additionally, the crate now preserves read-only file attributes on Windows during persistence, ensuring that files marked as read-only are not inadvertently made writable. Signal handling for automatic cleanup of temporary files is now gated behind the \signals\ feature toggle, allowing users to opt out of signal-based cleanup if needed.

gix-tempfile · high confidence

The gix-diff crate now supports shell commands in external blob diffs, treating configured diff drivers as full command lines rather than simple executable paths, which ensures custom text-conversion commands launch with their arguments intact. Additionally, the tree-merge change matching and resolution logic has been refactored to fix hangs, duplicate entries, and side-order-dependent merge results by separating path matching from scheduling and hardening the conflict resolution matrix.

gix-diff · high confidence

The \gix-discover\ crate now provides more accurate detection of repository kinds, including better handling of bare repositories, submodules, and linked worktrees. The \is\_git()\ function has been refined to correctly classify non-bare repositories without worktrees and to recognize repositories using ref-tables. Additionally, support for relative worktree directories has been added, and the \bare()\ function now ensures it detects bare repos by checking for the presence of an index file. The \path::repository\_kind()\ function and \RepositoryKind\ enum have been introduced to guess the repository type based on the \.git\ directory path, distinguishing between submodules, linked worktrees, and common repositories.

gix-discover/src · high confidence

The project now publishes its operational structure and financial history to enhance transparency. A new governance file defines the project as BDFL-led by 'byron' with specific maintainer privileges, while a new accounting file details monthly sponsorship payments received from GitHub Sponsors and a contributor expense payout between April 2021 and February 2022.

.gov · high confidence

The \src/porcelain\ module now provides the main entry point for the \ein\ command-line interface, replacing the previous \argh\-based implementation with \clap\. This change introduces a structured subcommand system including \init\ for repository creation, \completions\ for shell integration, and a new \tool\ subcommand group. The \tool\ group exposes analytics capabilities such as \estimate-hours\ (with options for ignoring bots, file/line stats, and identity unification), \query\ (a database-accelerated engine for tracing file paths), \find\ (for discovering repositories), and \organize\ (for structuring repositories by URL). The entry point also integrates signal-based interrupt handling and respects global flags for verbosity, progress display, and thread count.

src/porcelain · high confidence

The credential helper protocol now supports explicit serialization and deserialization of the context state via \write\_to\ and \from\_bytes\, allowing lossless round-tripping of fields like URL, protocol, host, username, password, and OAuth tokens. This change introduces methods to manage sensitive data safely: \clear\_secrets\ removes passwords and tokens, while \redacted\ replaces them with the string \\<redacted\>\ for safe logging or display. Additionally, the context can now be constructed directly from a URL string, and includes logic to destructure that URL into its component parts (protocol, host, path, etc.) while handling HTTP path significance and port inclusion. Input validation ensures that keys and values do not contain null bytes or newlines, and optionally rejects carriage returns if protocol protection is enabled.

gix-credentials/src/protocol/context · high confidence

The unified diff generation logic in \gix-diff\ has been replaced with a new implementation based on \imara-diff-v2\. This change introduces a new \UnifiedDiff\ struct that processes tokenized inputs to produce standard unified diff output, supporting configurable context sizes and handling both UTF-8 and non-UTF-8 content via a delegate-based consumption model. The new module defines core types like \ContextSize\, \DiffLineKind\, and \HunkHeader\ to structure the diff output, effectively shifting the diff algorithm dependency from the previous implementation to the \imara-diff\ crate.

_gix-diff/src/blob/unified\diff · high confidence

The README now uses a local SVG file (\etc/gix-asciicast.svg\) to display the terminal demo animation instead of an external asciinema embed. This change improves accessibility and reliability by removing the dependency on an external service and ensuring the demo renders consistently without network requests.

etc · high confidence

The gix-actor crate now exposes new Identity and IdentityRef types for representing a person's name and email without timestamp information, including methods for parsing, serialization, and conversion from Signature types. Additionally, the SignatureRef struct's time field has been changed from a decoded Time object to a raw string reference (&'a str) to preserve the original input for lossless round-tripping, requiring users to use the time() method to decode the timestamp when needed.

gix-actor/src · high confidence

The \gix index entries\ command is now available, replacing the previous \gix free index entries\ interface. It allows users to list index entries with support for pathspecs, optional attribute display (from worktree and index), statistics, and recursive submodule listing. The command also supports JSON and human-readable output formats, and includes options to skip hash computation when generating indices from trees or lists.

gitoxide-core/src/repository/index · high confidence

The configuration parser has been rewritten from scratch, removing the winnow dependency in favor of a custom, hand-implemented parser. This new implementation in \gix-config/src/parse/from\_bytes\ processes Git config files into span-delineated events without copying the input buffer, ensuring lifetime-free parsed data. It strictly adheres to Git's parsing rules, including handling of line continuations, comments, and section headers, while rejecting inputs larger than 4GB.

_gix-config/src/parse/from\bytes · high confidence

The \gix-config\ library now normalizes raw configuration values by stripping enclosing quotes and interpreting escape sequences (\\\n\, \\\t\, \\\b\) to match Git's behavior. This ensures that values containing escaped characters or quotes are processed consistently with standard Git tools, with the normalization logic exposed via a new \normalize\ function in the \value\ module.

gix-config/src/value · high confidence

The Docker test configuration for cross-context builds has been restructured to improve maintainability and conditional logic. The previously dense, inline RUN commands have been extracted into a new \customize.sh\ script, allowing for more complex setup steps to be executed cleanly. This script now handles the installation of \git\ and its dependencies with specific attention to cross-compilation architectures, ensuring that the correct architecture suffixes are applied for libraries and tools. It also includes logic to patch the Android runner script to suppress \LD\_PRELOAD\ warnings that interfere with test fixtures, and configures Git system settings required for specific test cases. This change centralizes the environment preparation logic, making it easier to manage dependencies and configuration for the gitoxide test suite across different target architectures.

etc/docker/test-cross-context · high confidence

The configuration snapshot module has been restructured to use a new \Key\ trait for accessing and setting values, replacing previous \Into\<&BStr\>\ approaches. This change introduces \SnapshotMut::set\_value()\ and \set\_subsection\_value()\ for modifying configuration, along with \Snapshot::credential\_helpers()\ to retrieve and configure credential helper cascades for specific URLs. The module also adds support for \core.askpass\ and \gitoxide.credentials.terminalPrompt\ settings, and implements automatic rollback for temporary configuration changes via \CommitAutoRollback\. These changes improve type safety and provide more convenient access to configuration values while maintaining backward compatibility through the \gix\_config::AsKey\ trait.

gix/src/config/snapshot · high confidence

The configuration cache system in \gix/src/config/cache\ has been restructured into distinct modules (\access\, \incubate\, \init\, \util\) to separate concerns. The \incubate\ module now handles the initial 'Stage One' loading of repository configuration, specifically managing the resolution of object hash types (including support for SHA-256-only builds) and repository format versions. The \init\ module centralizes the full cache initialization and provides a \reread\_values\_and\_clear\_caches\ method to allow dynamic updates to configuration values and cache invalidation. The \access\ module implements lazy evaluation for various configuration settings such as diff algorithms, merge drivers, and memory limits, while \util\ provides shared helpers for parsing boolean and integer configuration values with leniency support.

gix/src/config/cache · high confidence

The \gix-config\ section module now stores parsed configuration data as a span-backed view (\BodyRef\) that references the original file bytes rather than owning copies. This change introduces a lifetime-free parsing model where \BodyData\ holds parsed events and \BodyRef\ provides access to values by slicing the backing buffer, significantly reducing memory usage and allocation overhead when reading configuration files.

gix-config/src/file/section · high confidence

The \gix-actor\ signature parsing logic has been rewritten to remove the \winnow\ dependency in favor of hand-implemented parsers. This change introduces a new \decode\ module that handles parsing \SignatureRef\ and \IdentityRef\ directly from byte slices, supporting more lenient parsing behaviors such as handling missing timestamps, trailing numbers in offsets, and emails with spaces. The public API now exposes these new reference types with specific conversion and serialization methods, replacing the previous implementation.

gix-actor/src/signature · high confidence

The \gix-refspec\ crate has been updated to align its refspec parsing logic with Git's actual behavior. Push sources are no longer validated against ref-name or revision-spec patterns; any non-glob string is accepted as a source, matching Git's permissive handling of extended SHA-1 expressions. Additionally, refspecs are now split on the last colon rather than the first, correctly supporting sources that contain colons (such as \:/message\ or \\<rev\>:\<path\>\). The crate also enforces stricter pattern rules for fetch and push specifications, rejecting general wildcard expressions and one-sided fetch patterns that Git does not allow, while accepting partial negative refspecs as Git does.

gix-refspec · high confidence

The blame logic in \gix-blame\ has been rewritten to support starting the blame operation from a \Start\ type (which can be a commit or untracked worktree contents) instead of a raw ObjectId, and now includes options to filter results by a \since\ timestamp, specify a \diff\_algorithm\, and track the \blame\_path\ (file renames) across history. The implementation introduces \BlameRanges\ for multi-range support and integrates \imara-diff\ for blob diffing, providing users with more granular control over blame scope and better handling of file moves.

gix-blame/src/file · high confidence

The remote module has been reorganized into distinct files (access, build, connect, fetch, init, name, save) to improve clarity and maintainability. Key behavioral changes include the introduction of \with\_push\_url()\ and \with\_push\_url\_without\_url\_rewrite()\ builder methods for setting explicit push URLs, deprecating the older \push\_url()\ and \push\_url\_without\_url\_rewrite()\ methods. URL rewriting logic has been refined to handle \url.\<base\>.insteadOf\ and \pushInsteadOf\ rules more robustly, with non-destructive rewrites that preserve original URLs if rewrites fail. The \Remote::name()\ method now returns \Option\<&remote::Name\<'static\>\>\, supporting both symbolic names and direct URLs, and \Remote::save\_to()\ ensures that remote configurations are correctly persisted to the local config file, clearing existing sections before writing new values.

gix/src/remote · high confidence

The \gix-filter\ pipeline has been refactored to support a complete, streaming-compatible conversion process. The \Pipeline::new()\ constructor now accepts a \gix\_command::Context\ to provide crucial context (such as reference name and treeish) to external filter processes, and no longer requires the object hash directly in the constructor (it is now managed internally or via options). The conversion API has been unified: \convert\_to\_git\ now takes a stream and an \IndexObjectFn\ callback to fetch index data on demand, while \convert\_to\_worktree\ uses a new \Options\ struct that allows callers to specify how to handle unknown encodings (Ignore vs Fail) and whether process filters can delay their response. Additionally, the pipeline exposes mutable access to its internal buffers and driver state, enabling more efficient memory reuse and direct control over long-running filter processes.

gix-filter/src/pipeline · high confidence

The clone and fetch machinery in \gix/src/clone/fetch\ has been updated to align with Git's behavior for shallow clones. When performing a shallow clone without explicit refspecs, the system now automatically determines the target branch by fetching the remote's HEAD reference, ensuring the correct branch is checked out even if local defaults differ. Additionally, it supports cloning a single specific revision or branch via a single-branch refspec, and allows custom connection configuration during the initial fetch phase.

gix/src/clone/fetch · high confidence

The filter driver now supports a complete, streaming-compatible pipeline for checkouts, introducing the ability to delay filter processing for long-running processes. Users can now steer these processes, allowing filters to signal that they will process data later via a new \Delay\ mechanism, with dedicated APIs to list and fetch delayed paths. The driver also improves robustness by preserving input when optional filter drivers fail, handling broken pipes gracefully, and ensuring that every \%f\ placeholder in filter commands is substituted with the file path, matching Git's behavior.

gix-filter/src/driver · high confidence

The configuration parser now enforces strict rules on section and value names during parsing. Section names must consist only of ASCII alphanumeric characters and hyphens, while value names must start with an alphabetic character and also contain only alphanumeric characters and hyphens. Invalid names result in validation errors that include the offending input bytes, allowing users to inspect the specific cause of the failure via error metadata. This change ensures that only syntactically valid Git configuration keys are accepted, rejecting inputs with newlines, null bytes, or invalid characters.

gix-config/src/parse/section · high confidence

The \gix-date\ time module has been rewritten to use the \jiff\ crate for date and time operations, replacing the previous \time\ dependency. This change introduces new formatting capabilities via \Time::format()\ and \Time::to\_zoned()\, allowing for complex time computations and limitless formatting using \jiff::Zoned\. Serialization is now handled by \Time::write\_to()\, which outputs the standard git header format (seconds and offset). The module also adds \Time::format\_or\_unix()\ for infallible formatting that falls back to raw Unix timestamps on error, and provides constants for common formats like RFC2822, ISO8601, and Git-specific styles.

gix-date/src/time · high confidence

The repository initialization process now uses a new set of template files for the \.git\ directory, including updated sample hooks (such as \pre-commit\ and \commit-msg\), a new \description\ file, and a \HEAD\ file pointing to \refs/heads/main\. The initialization code in \create.rs\ and \init.rs\ has been reworked to embed these assets and enforce stricter checks, such as requiring an empty destination directory for bare repositories and validating the default branch name.

gix/src · high confidence

The upward discovery logic in \gix-discover\ has been refactored to introduce a \TrustPolicy\ option, allowing users to either require specific trust levels for discovered repositories or assume a trust level to skip computation. The discovery process now handles physical path traversal (resolving symlinks and \..\ components) more robustly to ensure correct ancestor reconstruction, and includes optimizations such as probing the \.git\ subdirectory early and avoiding redundant metadata queries. Additionally, the module exposes options to limit discovery to \.git\ directories (useful for worktrees) and to enforce ceiling directories, with environment variable overrides for ceiling paths.

gix-discover/src/upwards · high confidence

The \gix-status\ crate now supports a Windows-specific \fscache\ option (equivalent to Git's \core.fscache\) that caches directory metadata during status scans. This optimization reduces expensive per-file \lstat\ system calls by reusing metadata from parent directory enumeration, significantly improving performance on Windows worktrees. The feature is exposed via \index\_as\_worktree::Options::fscache\ and is internal to the \gix-status\ crate.

gix-status · high confidence

This release of the \gix\ crate introduces several significant changes. Most notably, it replaces the \maybe-async\ dependency with \bisync\ 0.3, altering the async execution model. Configuration handling is updated to use lifetime-free \gix\_config::File\ representations, meaning configuration lookups now return owned values (like \BString\ and \PathBuf\) instead of references, which simplifies API usage but is a breaking change. New features include \Repository::normalize\_path()\ for easier path normalization, \discover\_opts()\ for isolated discovery, and the addition of \tix\ to the \gix\ CLI. The release also respects configured zlib compression levels, introduces lazy evaluation of \core.fscache\ on Windows, and adds \Connection::configured\_credentials\_for\_current\_url()\ to handle URL redirects correctly. Several bug fixes are included, such as preserving multiple remote URLs, honoring \credential.protectProtocol\, and correctly handling \core.worktree\ paths in symlinked environments.

gix · high confidence

The gix-actor crate has been updated to version 0.42.0, incorporating internal manifest updates and adaptations to changes in the gix-testtools crate. Additionally, the crate now includes standard Apache-2.0 and MIT license files via symlinks to the repository root, ensuring consistent license distribution across the project.

gix-actor · high confidence

This release of gix-attributes introduces two breaking changes. First, it adapts to lifetime-free configuration files in gix-config, updating repository configuration storage, snapshots, overrides, and caches to use the self-contained gix\_config::File representation; this allows configuration to move through repository initialization, cloning, and remote setup without artificial input lifetimes, and changes configuration-derived lookups to return owned BString, PathBuf, OsString, and FullName values while simplifying fallible optional access. Second, it removes the kstring dependency in favor of Rc/Arc (with Arc enabled via the parallel feature), a change noted as approximately 4% faster.

gix-attributes · high confidence

The gix-bitmap crate has been updated to version 0.4.0, which includes manifest updates and adaptations to changes in the gix-testtools crate. Additionally, Apache-2.0 and MIT license files are now explicitly included in the package via symlinks to the repository root, ensuring proper license distribution for consumers of the library.

gix-bitmap · high confidence

The \git-chunk\ crate has been renamed to \gix-chunk\, requiring users to update their dependency declarations. Additionally, the crate now includes symlinks to the project's Apache-2.0 and MIT license files, ensuring proper license distribution in packaged releases.

gix-chunk · high confidence

The gix-config library has been updated to version 0.59.0, introducing a major breaking change where parsed configuration files are now lifetime-free. This allows parsed data to be stored, moved, and combined more easily by using a self-contained backing buffer and lightweight view types (EventRef, SectionRef, etc.). Additionally, a new \parse::format\ feature has been added to normalize git-config whitespace, allowing users to re-emit config files with sanitized spacing while preserving values and comments. Other changes include returning config values with their containing sections via \File::\*\_with\_sections()\ methods, adding \SectionMut::rename()\ for precise single-section renames, and fixing \File::rename\_section()\ to rename all matching sections instead of just the last one.

gix-config · high confidence

This release updates the gix-date crate to version 0.15.6, incorporating internal refactoring such as reducing the smallvec dependency and adding crate-root doctests. The changelog has been regenerated to reflect recent changes, and license files (LICENSE-APACHE, LICENSE-MIT) are now included as symlinks. Additionally, a new agents.md file provides guidance that parser fixes and improvements are not considered breaking changes.

gix-date · high confidence

This release improves debugging by preserving the underlying zlib error message when decompression fails, rather than flattening it to a generic 'corrupt deflate stream' message. It also fixes \in\_parallel\_with\_slice()\ to report the actual causal error that stopped execution, preventing reactive errors from masking the real cause. Additionally, the \zlib\ module has been removed in favor of the standalone \gix-zlib\ crate, which is a breaking change for users relying on the previous module.

gix-features · high confidence

The gix-filter crate now aligns with Git's behavior by continuing checkouts when working-tree encodings are unsupported (such as UTF-32) or when optional filter drivers fail, rather than rejecting the operation. It introduces \to\_worktree::Options\ to replace the \can\_delay\ flag, allowing callers to control strictness. Additionally, optional filter drivers that exit early or encounter broken pipes no longer cause checkout failures; instead, the original input is preserved as a fallback. These changes are marked as breaking due to the API shift in \to\_worktree::Options\.

gix-filter · high confidence

This release of gix-fs (v0.22.1) includes a security fix for [GHSA redacted], which previously allowed attackers to trick \gix clone\ into writing outside the repository by revalidating cached stack leaves before directory reuse. It also addresses a behavioral issue where filesystem capability probing in worktrees could misdetect case-sensitivity; the probe now correctly treats a linked worktree's admin directory as authoritative by checking \HEAD\. Additionally, the crate adds WASI (wasm32-wasip2) platform support and includes crate-root doctests.

gix-fs · high confidence

The gix-hash crate now uses sha1dc for SHA-1 hashing, which detects collision attacks and returns a corruption error instead of silently producing a hash. The crate has been updated to the Rust 2024 edition, and the MSRV has been raised accordingly. Additionally, the \sha1\ feature is no longer enabled by default, requiring users to explicitly opt-in if they need SHA-1 support.

gix-hash · high confidence

The gix-imara-diff crate has been updated to version 0.2.2, introducing a vendor of imara-diff v2. This update replaces the previous diff implementation with one that uses 'imara-diff-v2' and includes 'git sliders processing' for post-processing. This change improves diff quality at the cost of approximately 8% slower diff computation, while line-count computations become 50% faster. Additionally, the crate now includes comprehensive fuzz tests for all major algorithms (Myers, Histogram, MyersMinimal) and post-processing heuristics to ensure robustness against arbitrary inputs.

gix-imara-diff · high confidence

The gix-mailmap crate now matches Git's behavior when parsing mailmap lines containing a second identity or trailing content, ensuring that lines with extra data after the second email are no longer silently dropped. Additionally, fuzz testing has been added for the mailmap parser to improve robustness against malformed input.

gix-mailmap · high confidence

This release introduces a breaking change by replacing the \maybe-async\ dependency with \bisync\ to manage async and sync execution modes, requiring users to update their async runtime integration. It also fixes a critical panic ([GHSA redacted]) that occurred when processing empty sideband payloads in progress or error packets, ensuring robust handling of malformed protocol data. Additionally, the crate now includes fuzz tests and a corpus builder to improve security and stability.

gix-packetline · high confidence

The gix-submodule crate has been updated to version 0.32.0, introducing a major architectural shift by making parsed configuration files lifetime-free. This change removes input lifetimes from the \File\ and \Events\ types, allowing configuration data to be stored, moved, and combined more easily. The API has been simplified to return owned \BString\ values from lookups, replacing previous \Cow\ handling, and optional typed lookups now return \Result\<Option\<T\>, E\>\ instead of \Option\<Result\<T, E\>\>\. Additionally, the \Submodule::path()\ method now returns a \BString\ directly, and configuration value name validation is performed internally using \AsBStrOpt\ for value pushes, making the API more convenient and robust for users.

gix-submodule · high confidence

This release of gix-url v0.37.1 introduces several bug fixes and a new feature to improve URL parsing accuracy and security. A new \Url::original\_path()\ method allows access to the original percent-encoded path, preserving the exact spelling of escaped characters. Parsing now better matches Git's edge cases, including support for scoped IPv6 literals and correct handling of HTTP paths. Security is enhanced by validating URL schemes and percent escapes, rejecting malformed authorities, and terminating authorities at query and fragment delimiters to prevent identity confusion. Additionally, colons in usernames are now preserved during serialization to avoid misinterpretation as password delimiters.

gix-url · high confidence

The \gix-worktree-state\ checkout logic now correctly handles several edge cases: it truncates files to the exact length of the blob to prevent leftover data, removes obsolete executable bits when overwriting non-executable files in non-exclusive checkouts, and preserves executable bits for files processed by delayed filters. Additionally, it rejects terminal symlinks during checkout to prevent security issues on Windows, uses the \Delegate\ for Windows terminal symlink checks, and continues checkout when encountering unavailable text encodings instead of failing.

gix-worktree-state · high confidence

The \gix-config-value\ crate now handles color configuration values more robustly: color names are matched case-insensitively (including the \reset\ keyword), and the \bright\ prefix is now validated to require a standard color name, aligning behavior with Git's own parsing rules.

gix-config-value · high confidence

The \gix-command\ crate now correctly handles executable paths and shebang lines. It invokes existing absolute paths directly, bypassing shell detection to prevent accidental splitting of paths containing spaces (such as those in Windows Program Files). Additionally, it safely splits commands by ignoring shebang options, ensuring that executable contents do not alter the interpreter invocation, and uses a byte-oriented parser to preserve non-UTF-8 programs and arguments.

gix-command · high confidence

The object database now respects the configured loose-object compression levels (e.g., \core.looseCompression\) instead of using a hard-coded default, ensuring consistency with Git's behavior. Additionally, the store now correctly retries cleared pack slots during loading, allowing it to recover from index state issues that previously caused failures.

gix-odb · high confidence

The \gix-revision\ crate now correctly handles revision specifications that previously behaved differently from Git. It fixes the parsing of \\<rev\>^{/}\ with an empty pattern, ensuring it resolves to the underlying commit (peeling annotated tags) rather than the tag object itself, and correctly rejects negated empty patterns. Additionally, it now accepts \:3:\<path\>\ to access the 'theirs' index stage during merges, aligning with Git's support for stages 0-3, whereas previously only stages 0-2 were recognized.

gix-revision · high confidence

The gix-ref crate now aligns its ref transaction locking behavior with Git by removing a global lock optimization that previously allowed races with external Git processes. It also closes a Time-Of-Check-Time-Of-Use (TOCTOU) race in the Compare-And-Swap (CAS) check during ref transaction preparation by reading the existing ref value only after acquiring the lock, preventing silent update loss. Additionally, Windows device names (like CON) are now validated before lock acquisition to prevent lock failures, and symbolic ref files are now correctly parsed to tolerate NUL suffixes, matching Git's behavior.

gix-ref · high confidence

Add baseline generation script for date parsing tests; Add fuzzing harnesses for gix-config file parsing and manipulation; Add internal test-tooling commands for generating reproducible test fixtures; Add tests for index and tree diff capabilities; Added baseline test fixtures for git-attributes matching; Added basic test fixture for gix-archive; Added benchmarks for diff line counting and rewrite tracking; Added benchmarks for large config parsing and section/value lookups; Added comprehensive test suite for blob diffing capabilities; Added comprehensive tests for directory walking behavior; Added comprehensive tests for gix-config file parsing, serialization, and include resolution; Added comprehensive tests for gix-date time parsing, formatting, and serialization; Added comprehensive tests for gix-error classification, error chains, and metadata; Added comprehensive tests for revision spec parsing; Added fuzz testing for date parsing; Added fuzz testing for gix-actor identity and signature parsing; Added fuzz testing for gix-attributes search functionality; Added fuzz testing for gix-command parsing and preparation; Added fuzz testing for gix-commitgraph File API; Added fuzz testing for gix-config-value; Added fuzz testing for gix-credentials Context; Added fuzzing crash artifact to test suite; Added fuzzing harness for transport handshake inspection; Added fuzzing regression tests for EWAH bitmap decoding; Added fuzzing test case for gix-config parser; Added fuzzing test fixtures for gix-config; Added gix-attributes lookup benchmarks; Added integration tests for gix-archive tar and internal formats; Added integration tests for repository configuration, initialization, and interrupt handling; Added integration tests for repository discovery and path parsing; Added memory usage test for config parsing; Added programmatic tests for credential helper execution and protocol validation; Added shell script fixtures for gix-credentials tests; Added test coverage for config value parsing and path interpolation; Added test fixture generation script for fsck tests; Added test fixtures for Windows path lookup behavior; Added test fixtures for blame rename tracking, symlinks, and multiple roots; Added test fixtures for commit-graph generation and structure edge cases; Added test fixtures for directory walk edge cases; Added test fixtures for git filter pipeline scenarios; Added test fixtures for gix-diff validation; Added test fixtures for jj-trackcopy-1; Added test for current\_dir unicode precomposition; Added test for directory walk prefix matching; Added test helper for filter driver process communication; Added test utilities for directory walk operations; Added tests for EOL conversion and binary detection logic; Added tests for atomic configuration file editing and validation error diagnostics; Added tests for chunk table validation errors; Added tests for command-line parsing, context handling, and shebang interpretation; Added tests for commit graph access and generation number handling; Added tests for commit-graph parsing and error handling; Added tests for conditional config includes and path resolution; Added tests for config formatting, key parsing, and source resolution; Added tests for config parsing error diagnostics, formatting normalization, and section validation; Added tests for config value normalization; Added tests for connectivity checks and SHA-256 hash support; Added tests for credential helper cascade, context serialization, and invocation; Added tests for credential protocol context handling; Added tests for diff rewrite tracking logic; Added tests for directory creation and removal logic; Added tests for filesystem capabilities, permissions, and path handling; Added tests for filter driver lifecycle, identity expansion, and worktree encoding; Added tests for gix-attributes parsing, assignment, search, and state handling; Added tests for gix-config file access mutations and read-only lookups; Added tests for gix-config file initialization; Added tests for identity and signature parsing and validation; Added tests for mutable config file operations; Added tests for parallel iteration and reduction primitives; Added tests for parallel optimization, I/O pipes, and tracing macros; Added tests for raw config value access and mutation; Added tests for reference comparison, remote name resolution, and error classification; Added tests for remote connection, fetch, and configuration saving; Added tests for repository blame, branch, filter, mailmap, merge, notes, object, open, pathspec, reference, and remote operations; Added tests for repository config snapshot behavior; Added tests for repository configuration behavior; Added tests for repository discovery edge cases; Added tests for the auto-chain-error feature; Added tests for the filter pipeline conversion behavior; Added tests for tree object diffing and entry traversal; Added tests for upward repository discovery behavior; Expanded integration test coverage for core gix operations; Expanded journey test coverage for gix and ein tools; Expanded test coverage for date parsing edge cases and relative time arithmetic; Expanded test fixtures for repository discovery scenarios; Initial test suite for gix-blame; Introduce revision::Spec parsing with disambiguation and reflog support; gix-object 0.64.1 release.

This change updates dependencies across 97 manifests in the workspace, including bumps to crates such as openssl, zip, sdd, tar, crc, and the windows crate, as well as general dependency refreshes to keep the project aligned with the latest available versions.

(dependencies) · high confidence

gitoxide-core v0.61.1 release notes and license symlinks; gix-revwalk v0.35.0 release.

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 68 → 69 (+0.9)
• Rubric changed (rubric-2026.09.8 → rubric-2026.09.17) — scores are not directly comparable.

• Code Health 78 → 78 (-0.0)
• Architecture 99 → 93 (-6.1)
• Maturity 64 → 65 (+1.1)
• Readiness 97 → 88 (-8.5)
• Security 71 → 78 (+7.3)
• Domain Modelling 100 → 100 (+0.0)
• Event Sourcing 100 → 100 (+0.0)
• Accessibility 62 → 62 (+0.0)
• Performance 100 (new)

• Boundary-crossing change coupling: body.rs ↔ decode.rs (gix-object/src/commit/message/body.rs)
• Boundary-crossing change coupling: decode.rs ↔ decode.rs (gix-actor/src/signature/decode.rs)
• Change coupling: body.rs ↔ parse.rs (gix-object/src/commit/message/body.rs)
• Change coupling: body.rs ↔ ref_iter.rs (gix-object/src/commit/message/body.rs)
• Change coupling: namespace.rs ↔ iter.rs (gix-ref/src/namespace.rs)
• Duplicated block (10 lines × 2) (gix-filter/src/driver/process/client.rs)
• Duplicated block (10 lines × 2) (gix-filter/src/eol/convert_to_git.rs)
• Duplicated block (10 lines × 2) (gix-packetline/src/async_io/read.rs)
• Duplicated block (10 lines × 2) (gix/src/object/impls.rs)
• Duplicated block (11 lines × 2) (gitoxide-core/src/repository/merge/commit.rs)
• Duplicated block (11 lines × 2) (gix-tix/src/edit/rebase.rs)
• Duplicated block (13 lines × 2) (gix-odb/src/store_impls/loose/write.rs)
• Duplicated block (13 lines × 3) (gix/src/repository/attributes.rs)
• Duplicated block (15 lines × 2) (gix-odb/src/store_impls/loose/write.rs)
• Duplicated block (16 lines × 2) (gix-object/src/tree/write.rs)
• Duplicated block (18 lines × 2) (gix-object/src/signature/sign.rs)
• Duplicated block (20–21 lines × 2) (gix-odb/src/store_impls/loose/find.rs)
• Duplicated block (5 lines × 4) (gix-worktree/src/stack/state/attributes.rs)
• Duplicated block (6 lines × 2) (gix-hash/src/prefix.rs)
• Duplicated block (6 lines × 2) (gix-object/src/traits/find.rs)
• …and 46 more

• Boundary-crossing change coupling: decode.rs ↔ decode.rs (gix-actor/src/signature/decode.rs)
• Boundary-crossing change coupling: decode.rs ↔ decode.rs (gix-actor/src/signature/decode.rs)
• Boundary-crossing change coupling: decode.rs ↔ decode.rs (gix-object/src/commit/message/decode.rs)
• Boundary-crossing change coupling: decode.rs ↔ mod.rs (gix-object/src/commit/message/decode.rs)
• Boundary-crossing change coupling: decode.rs ↔ parse.rs (gix-object/src/commit/message/decode.rs)
• Change coupling: cascade.rs ↔ serde.rs (gix-credentials/src/helper/cascade.rs)
• Change-coupling hub: body.rs → decode.rs, parse.rs, ref_iter.rs (gix-object/src/commit/message/body.rs)
• Duplicate output configuration properties with different types. Similar to the status module, revision.list exposes both format (generic OutputFormat) and text (specific Format). This inconsistency across modules suggests a lack of unified design for how output formatting is handled in context objects versus options structs.
• Duplicate output configuration properties with different types. output_format uses the generic OutputFormat enum, while format uses a domain-specific Format enum. This forces users to choose between a generic and a specific formatter for the same operation, creating confusion about which one takes precedence or if they are redundant.
• Duplicated block (10 lines × 2) (gix-filter/src/driver/process/client.rs)
• Duplicated block (10 lines × 2) (gix-hash/src/object_id.rs)
• Duplicated block (10 lines × 2) (gix-packetline/src/async_io/read.rs)
• Duplicated block (10 lines × 2) (gix-protocol/src/handshake/refs/async_io.rs)
• Duplicated block (11 lines × 2) (gitoxide-core/src/repository/merge/commit.rs)
• Duplicated block (11 lines × 2) (gix-diff/src/tree/function.rs)
• Duplicated block (11 lines × 2) (gix/src/clone/fetch/mod.rs)
• Duplicated block (11 lines × 2) (gix/src/worktree/remove.rs)
• Duplicated block (12 lines × 2) (gix/src/config/tree/sections/core.rs)
• Duplicated block (13–15 lines × 2) (gix-merge/src/blob/pipeline.rs)
• Duplicated block (15 lines × 2) (gix-protocol/src/handshake/refs/async_io.rs)
• …and 80 more

• 149 commits — 107 feature/other, 42 fixes

• (repo) — 27 commits
• (root) — 16 commits
• gix/src — 12 commits
• gix-error/src — 7 commits
• gix-glob/tests — 4 commits
• gix-merge/src — 4 commits
• gix-pack/src — 4 commits
• gix-ref/src — 4 commits
• gix/tests — 4 commits
• gix-object/src — 3 commits
• gix-protocol/src — 3 commits
• gix-transport/src — 3 commits
• .agents/skills — 2 commits
• etc/reports — 2 commits
• gitoxide-core/src — 2 commits
• gix-credentials/src — 2 commits
• gix-date/tests — 2 commits
• gix-fs/src — 2 commits
• gix-odb/src — 2 commits
• gix-path/src — 2 commits

• fix: Merge pull request #2992 from GitoxideLabs/fix-message-newline
• fix: Merge pull request #2993 from youdie006/fix-blank-space-character-classes
• fix: Merge pull request #2994 from rawsun007/fix-date-offset-range
• fix: Merge pull request #3002 from GitoxideLabs/fix-8bit-date
• fix: Merge pull request #3006 from GitoxideLabs/gix-fs-fix
• fix: Merge pull request #3013 from Mrmaxmeier/fix-gix-bitmap-ewah-usize32-overflow
• fix: Merge pull request #3024 from goldjacobe/fix-tree-merge-keep-dir-on-leaf-removal
• fix: Merge pull request #3026 from GitoxideLabs/status-fix
• fix: fix CI
• fix: fix(gitoxide-core): validate received ref names before writing (#3005)
• fix: fix(gix)!: preserve causes across fallible conversions
• fix: fix(gix): anchor worktree removal paths to the repository CWD
• fix: fix(gix): propagate failed fetch ancestry checks
• fix: fix(gix-bitmap): reject chunk length that overflows 32-bit usize
• fix: fix(gix-command): classify malformed command lines
• fix: fix(gix-date): reject a timezone offset git would not read
• fix: fix(gix-date): reject ambiguous bare numeric dates (#3001)
• fix: fix(gix-dir): keep uninitialized submodules tracked (starship/starship#6881)
• fix: fix(gix-error): keep drained exceptions safe to inspect
• fix: fix(gix-error): preserve classifications in custom I/O payloads
• …and 129 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

GitoxideLabs/gitoxide was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.