Skip to content
CAI
Software that uses CAICheck a score

atuinsh/atuin

57.2

Adequate · 26 October 2026

181.5k

lines of production code

Rust

primary language

6

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Atuin is a command history and shell environment synchronization tool that captures terminal sessions, AI agent interactions, and dotfile configurations across multiple devices. It operates via a background daemon that manages an in-memory search index and persists data to local SQLite and Fjall stores, syncing encrypted records to a configurable server backend. The system provides a rich interactive CLI for fuzzy searching history and output, managing scripts, and reviewing AI coding sessions, while supporting a wide range of shells and operating systems.

How it got here

2020–2024 — monorepo restructuring and daemon integration

31 changes.

The project underwent a major architectural shift by migrating to a Rust workspace monorepo and introducing a background gRPC daemon for history and search management. This period saw the removal of legacy local storage in favor of a polymorphic server backend, alongside the addition of new features like dotfiles synchronization, AI session tracking, and comprehensive shell integration.

2025–2026 — Daemon architecture and AI integration

38 changes.

This period focused on establishing a robust daemon-centric architecture, introducing in-memory search with frecency ranking, structured output capture, and comprehensive AI session management. The work also involved significant infrastructure improvements, including a unified database backend, strict version compatibility checks, and a migration to Buildkite for CI.

Features

AI session capture and management infrastructure

Atuin AI now captures and stores AI agent sessions in a local SQLite database, making them browsable and searchable via the new \atuin ai session\ command. This change introduces a new schema with tables for sessions, session events, session metadata, and usage snapshots, along with a build script to ensure migrations are correctly embedded at compile time. The \atuin ai session\ command provides subcommands to list, show, search, and tail these captured sessions, allowing users to review past AI interactions and their outcomes.

crates/atuin-ai · high confidence

AI session capture daemon interface defined

The daemon now exposes a new gRPC service for capturing and managing AI coding sessions. This interface allows clients to list, search, and stream sessions from supported harnesses (Claude Code, Codex, Copilot, OpenCode, and Pi), including detailed message content, tool calls, and token usage. It also supports importing existing on-disk sessions, rebuilding session data from the record store, and tailing live session updates.

crates/atuin-daemon/proto/ai · high confidence

Add Atuin shell history tool to devcontainer features

This change introduces a new devcontainer feature that installs Atuin, a shell history tool, within the development environment. The feature configures shell hooks for both zsh and bash to enable history recording and provides a sandbox-safe daemon configuration with a fixed socket path, ensuring compatibility with container environments that lack standard runtime directories.

.devcontainer/features/atuin · high confidence

Add health check endpoint and restructure server handlers

The server now exposes a /healthz endpoint that returns a 200 OK status with a JSON body indicating 'healthy', allowing external monitoring systems to verify service availability. Additionally, the handler module has been reorganized to include user management endpoints (register, login, delete, change password) and an API index endpoint that can optionally advertise a fake version string to clients, while introducing a standardized error response wrapper for consistent HTTP status reporting.

crates/atuin-server/src/handlers · high confidence

Add project configuration and contributor documentation files

The repository now includes standard configuration and documentation files to improve development workflow and community guidelines. This adds \.editorconfig\ for consistent editor settings, \.rustfmt.toml\ for Rust formatting rules, \.codespellrc\ for spell-checking, \.vale.ini\ for prose linting, \.gitattributes\ for line-ending consistency, \.mailmap\ for author normalization, and \.dockerignore\ for build context. It also introduces \AGENTS.md\ as a developer guide for AI assistants and workspace conventions, \CODE\_OF\_CONDUCT.md\ for community standards, and \CONTRIBUTORS\ for listing contributors.

(repo-wide) · high confidence

Add sorting and filtering to dotfiles alias and variable lists

The \atuin dotfiles alias list\ and \atuin dotfiles var list\ commands now support sorting by name or value, reversing the output order, and filtering results by name or value patterns. For variables, users can also restrict the output to only exported variables or only shell-only variables using the \--exports-only\ and \--shell-only\ flags.

crates/atuin/src/command/client/dotfiles · high confidence

Add systemd service and user configuration for the Atuin server

Users can now deploy the Atuin server using systemd. A new service unit file (atuin-server.service) is provided to manage the server process, running it as a dedicated 'atuin' user with strict security hardening options such as protected system paths and no new privileges. A corresponding sysusers configuration file (atuin-server.sysusers) is included to automatically create the 'atuin' system user upon installation.

systemd · high confidence

Atuin server now available as a standalone binary

The Atuin server is now distributed as a dedicated binary crate, allowing users to run the server independently. The new binary exposes a command-line interface with a 'start' subcommand to launch the sync server (accepting optional host and port arguments) and a 'default-config' subcommand to print the example configuration, simplifying deployment and configuration management.

crates/atuin-server/src/bin · high confidence

Atuin server restructured with metrics, health checks, and capability negotiation

The server crate has been reorganized to introduce a dedicated metrics endpoint (exposed on a separate listener to avoid public exposure), a \/healthz\ health-check route, and a capabilities-driven negotiation protocol that allows clients and servers to agree on features like page size. The server now advertises a configurable fake version to prevent unnecessary client update prompts, supports polymorphic database backends (SQLite, Postgres, MySQL) via a unified interface, and includes improved HTTP tracing and logging for operational visibility.

crates/atuin-server/src · high confidence

Daemon now captures and stores AI agent sessions

The Atuin daemon now automatically captures AI agent sessions (from supported harnesses) and stores them in the local session store. This includes capturing tool calls, message history, and file patches, with configurable policies for redacting secrets and filtering sensitive commands or directories. A background engine manages live capture, while a separate importer allows backfilling existing session data. The system includes robust recovery mechanisms to handle store rebuilds and ensure data integrity across daemon restarts.

_crates/atuin-daemon/src/session\capture · high confidence

Daemon search component with in-memory index and frecency ranking

The daemon now includes a dedicated search component that maintains an in-memory fuzzy search index of command history using the Nucleo library. This component loads history from the database on startup, supports dynamic filtering (such as by shell), and applies frecency-based ranking to prioritize results. It exposes a gRPC service for search requests and runs background tasks to periodically refresh the frecency map and handle index updates, replacing previous search mechanisms with this more performant, daemon-owned approach.

crates/atuin-daemon/src/components · high confidence

Interactive search gains syntax highlighting, vim-style navigation, and an inspector

The interactive history search now highlights commands with syntax coloring (using tree-sitter for bash, zsh, fish, and PowerShell) and supports configurable word-jump navigation (Emacs or Sublime Text modes) for faster cursor movement. An interactive inspector panel provides detailed statistics and context for selected history entries, while the search UI also introduces ultracompact mode and customizable columns.

crates/atuin/src/command/client/search · high confidence

Introduce Fluent-based internationalization for user-facing text

User-facing strings in the CLI are now managed via Fluent resource files (e.g., en-US/atuin.ftl), covering help text, prompts, error messages, and configuration descriptions. This change establishes the foundation for localizing the application into other languages, while the English strings remain the default for now.

crates/atuin/i18n · high confidence

Introduce Octavo hub client with history and output upload queues

This change adds the \atuin-octavo\ crate, which provides a client for the new Octavo hub service. It includes generated Protobuf code for the \HubService\ (handling history insertion, deletion, and output storage) and implements a local SQLite-based upload queue. The queue manages pending history uploads, history deletions, and command output uploads, persisting them in new database tables (\history\_uploads\, \history\_deletions\, \output\_uploads\) to ensure reliable synchronization with the hub.

crates/atuin-octavo · high confidence

Introduce command output capture with configurable size limits

The PTY proxy now captures the rendered output of commands executed in the terminal. It uses a new Atuin-specific OSC escape sequence (18188735) to mark the start and end of each command's output. Captured output is stored with a configurable maximum size (\max\_output\_bytes\); when the limit is exceeded, the middle of the output is dropped while preserving the start and end. The capture includes the terminal size and handles scrollback, ensuring that partial lines are trimmed to maintain data integrity for features like secret redaction.

crates/atuin-pty-proxy/src · high confidence

Introduce daemon protocol definitions for AI session capture and command output search

The daemon's protobuf interface now includes new services and message types to support AI coding agent session tracking and full-text search of captured command output. The \ai/agent.proto\ and \ai/session.proto\ files define the data structures for recording AI interactions (including tool calls, reasoning, and token usage) and provide RPCs to list, search, stream, and import these sessions. Additionally, \search.proto\ adds a \SearchCommandOutput\ RPC to query the full-text index of command output, while \history.proto\ is updated with \AuthorKind\ to distinguish between human and agent command execution.

crates/atuin-daemon/proto · high confidence

Introduce dotfiles sync for shell aliases and environment variables

The new \atuin-dotfiles\ crate adds the ability to sync shell aliases and environment variables across devices. It defines data structures for aliases and variables (distinguishing between shell and environment variables) and provides storage logic using SQLite and Paseto encryption. The implementation includes formatters to generate configuration snippets for POSIX shells, Xonsh, and PowerShell, enabling users to maintain consistent shell environments via Atuin.

crates/atuin-dotfiles/src · high confidence

Introduce official devcontainer configuration with Rust toolchain and Claude integration

Developers can now use the provided \.devcontainer\ setup to launch a consistent development environment in VS Code or compatible editors. The configuration installs a Rust-based image with essential build tools (protoc, mold linker, clang), sets up the \dev\ user with passwordless sudo, and pre-installs the Claude Code CLI. It also includes a custom devcontainer feature for Atuin (with sandbox-safe daemon configuration) and GitHub CLI, while temporarily disabling Tailscale and Atuin in the entrypoint to prevent startup hangs in automated sandbox environments.

.devcontainer · high confidence

Introduce script storage, syncing, and execution capabilities

This change adds a new \atuin-scripts\ crate that enables users to store, sync, and execute scripts. It introduces a SQLite-backed database with \scripts\ and \script\_tags\ tables, a \ScriptStore\ for managing script records (create, update, delete) via encrypted sync, and an execution engine that supports interactive script running with stdin/stdout handling and template rendering via MiniJinja. The implementation includes serialization/deserialization of script records for sync and ensures unique script names.

crates/atuin-scripts · high confidence

Introduce shared domain crate with capability negotiation and typed record models

A new \atuin-domain\ crate has been added to centralize shared domain types across the client, daemon, and server. This includes a capability negotiation system that allows clients and servers to exchange supported features (such as packfiles and page sizes) via a token-based protocol, ensuring compatibility during sync. The crate also introduces strongly-typed models for history records, including \RecordVersion\, \RecordTag\, and \CmdOrigin\ (replacing the previous \host:user\ string parsing with explicit host and user types), along with API request/response structures for authentication and account management.

crates/atuin-domain · high confidence

Introduce structured output capture data models

The output capture module now exposes explicit data structures for handling captured terminal output, including \OutputMatch\ and \OutputLine\. These types define how search results are represented, with \OutputMatch\ containing a history ID, a relevance score, and a vector of \OutputLine\ objects that track line positions (including support for negative indices to represent discarded middle sections of large outputs) and highlighted content. This establishes the core data contract for the output capture engine and persistence layer.

_crates/atuin-daemon/src/output\capture · high confidence

The Atuin client now communicates with a new background daemon process via gRPC instead of accessing the database directly. This daemon manages command history lifecycle (start, finish, cancel, delete), maintains an in-memory search index, and handles output capture, exposing these capabilities through a new client library and a configurable socket (Unix socket on Linux/macOS, TCP on Windows).

crates/atuin-daemon/src · high confidence

Introduces gRPC common utilities for capped stream collection and protobuf conversions

The daemon now includes a new \grpc/common\ module providing shared utilities for handling gRPC requests. This adds a \TryCollectResultsCappedExt\ trait that safely drains client-streamed, chunked requests into a validated vector while enforcing a maximum item limit, returning a specific error if the cap is exceeded. It also includes protobuf conversion implementations for mapping domain record IDs to \RecordId\ and handling unsigned index ranges, along with comprehensive tests for the collection logic.

crates/atuin-daemon/src/grpc/common · high confidence

Introduces gRPC wire-format conversion utilities for AI agent sessions

This change adds the \pb.rs\ module within the \atuin-daemon\'s AI agent gRPC layer, providing the serialization and deserialization logic that maps internal domain types (such as \Session\, \Message\, \HarnessSession\, and \Content\) to and from the protobuf wire format. This enables the daemon to correctly encode and decode AI session data, including complex structures like tool calls, reasoning summaries, and patches, for transmission over the gRPC interface.

crates/atuin-daemon/src/grpc/ai/agent · high confidence

Introduction of the Atuin Daemon with gRPC interface and protobuf definitions

This change introduces a new background daemon service (\atuin-daemon\) that exposes Atuin's functionality via a gRPC interface. The implementation includes a build script that compiles Protocol Buffers (using \protox\) for core modules (common, history, search) and AI session tracking, along with Rust source files defining the gRPC transport layer, versioned reply traits, and error handling macros. This establishes the foundational communication channel between the client and the daemon for history management and AI session capture.

crates/atuin-daemon · high confidence

New \`atuin account\` command for user management

A new \atuin account\ subcommand has been added to manage user accounts, providing subcommands for login, register, logout, delete, change password, and link. The implementation introduces a \PasswordArg\ type that allows passwords to be passed directly or read securely from stdin (using \-\), with a fallback to the \ATUIN\_PASSWORD\ environment variable. This centralizes account operations and improves security by avoiding password exposure in command-line arguments.

crates/atuin/src/command/client · high confidence

New \`atuin output search\` command for querying captured command output

Users can now search the full text of previously captured command outputs using the new \atuin output search\ command. This feature allows you to find commands based on their stdout/stderr content, not just the command string itself. The search results can be displayed in several styles: \plain\ for simple text, \pretty\ for a formatted view with metadata (time, duration, exit code), \json\ for structured data, or \ndjson\ for newline-delimited JSON. The command integrates with the Atuin daemon for efficient searching and supports context lines to show surrounding output.

crates/atuin/src/command/client/output · high confidence

New account management commands for password changes, account deletion, and CLI-Hub linking

The client now exposes dedicated CLI commands to change passwords, delete accounts, and link an existing CLI session to an Atuin Hub account. The \change\_password\ command supports two-factor authentication via TOTP and validates that the user is logged in before attempting the update. The \delete\ command removes the account on the server, cleans up local CLI and Hub session metadata, and also supports TOTP. The \link\ command allows users who already have a CLI session to authenticate with Atuin Hub via a browser flow and associate their CLI identity with their Hub account. These commands integrate with the existing i18n system for user-facing messages and use secrecy types for sensitive inputs.

crates/atuin/src/command/client/account · high confidence

New atuin-history crate with smart search sorting and command statistics

The new \atuin-history\ crate introduces a smart sorting algorithm for search results that prioritizes commands starting with the query and favors more recent history, alongside a statistics module that calculates command usage counts while intelligently ignoring leading environment variables and handling pipe-separated commands.

crates/atuin-history/src · high confidence

New automated release script for Atuin CLI

A new \scripts/release.sh\ script has been added to automate the Atuin CLI release process. This tool handles dependency checks (git, cargo, gh, etc.), creates a temporary working directory, detects the current version, suggests the next version based on conventional commits, and guides the user through confirming and executing the release steps.

scripts · high confidence

New command-line structure and OpenTelemetry tracing support

The \atuin\ CLI has been restructured into a modular command system under \crates/atuin/src/command\, introducing a unified entry point that manages subcommands (such as \search\, \stats\, \history\, \config\, and \daemon\) and handles process initialization, including daemonization and runtime selection. Additionally, the application now supports OpenTelemetry tracing; when compiled with the \profiling-traced\ feature, users can enable span export to an OTLP collector by setting the \ATUIN\_OTEL\ environment variable, with the system automatically handling log file rotation and cleanup.

crates/atuin/src/command · high confidence

New extensible keybinding system for search TUI

The search interface now uses a new keybinding framework that supports conditional rules, allowing keys to behave differently based on context (e.g., cursor position, input state, or list boundaries). This enables features like context-aware scrolling (exiting at boundaries), conditional acceptance (e.g., accepting at line start/end), and multiple keymaps (Emacs, Vim Normal/Insert, Inspector, Prefix). Users benefit from more intuitive and customizable navigation and editing within the search UI.

crates/atuin/src/command/client/search/keybindings · high confidence

New gRPC API for AI agent session management

The daemon now exposes a new gRPC service for managing AI agent sessions, enabling clients to list, retrieve, search, and tail session events. This service integrates with the session capture subsystem to support filtering by harness, workspace, directory, branch, model, and message roles, while also handling startup recovery states to ensure data consistency during rebuilds.

crates/atuin-daemon/src/grpc/ai/session · high confidence

New gRPC History service for daemon-side command tracking

The daemon now exposes a dedicated gRPC service to manage command history lifecycle events. Clients can start, end, cancel, and delete history entries, as well as rebuild or compact the underlying store. A streaming endpoint allows subscribers to tail history events in real-time, receiving notifications for command state changes or stream lag. This implementation moves history management logic into the daemon, utilizing a local journal for event tracking and ensuring that history operations are handled asynchronously to prevent client disconnects from interrupting long-running tasks.

crates/atuin-daemon/src/grpc/history · high confidence

New in-memory search index with frecency ranking in the daemon

The daemon now uses a new in-memory search index (crates/atuin-daemon/src/search) that deduplicates commands and ranks results using a frecency algorithm (frequency + recency). This enables efficient fuzzy matching and dynamic filtering by directory, host, and session, while allowing users to tune the relative weights of recency and frequency via multipliers.

crates/atuin-daemon/src/search · high confidence

New interactive inspector with output view and refined keybindings

The search interface now includes an inspector mode that lets you browse command runs, sessions, and statistics, with a new Output view that fetches and displays captured terminal output from the daemon. Keybindings are now resolved dynamically based on context (such as cursor position or list boundaries), and the UI provides clearer feedback on which keys are active or remapped.

crates/atuin/src/command/client/search/inspector · high confidence

New shared database and terminal utilities in atuin-common

The atuin-common crate now provides a comprehensive SQLite abstraction layer, including a builder for connection options (WAL mode, journaling, permissions), a background WAL compactor to manage disk usage under high concurrency, and full-text search (FTS5) helpers with text highlighting. It also introduces ANSI terminal rendering utilities that convert terminal output to plain text using the vt100 parser, along with benchmarking infrastructure and configuration to ban error-handling crates like eyre and anyhow for library safety.

crates/atuin-common · high confidence

New store management commands for record-based sync

The client now includes a new set of commands under the \store\ subcommand to manage the underlying record store used for syncing. Users can pull records from the server (\store pull\), push local records to the server (\store push\), and purge undecryptable records (\store purge\). Additionally, the \store rebuild\ command allows users to rebuild the local search index for history or scripts, while \store rekey\ enables re-encrypting the local store with a new key, and \store verify\ checks that the current key can successfully decrypt the local store.

crates/atuin/src/command/client/store · high confidence

New v0 API handlers for user info, records, and store management

The server now exposes a new v0 API module containing handlers for retrieving the authenticated user's profile (\me\), uploading and retrieving encrypted records (\record\), and deleting the user's store (\store\). The record handler enforces a configurable maximum record size, rejects oversized uploads with a 400 error, and tracks upload/download metrics. The store handler allows users to delete their entire store data. These endpoints rely on the new \atuin-domain\ types for request/response structures and the polymorphic database interface.

crates/atuin-server/src/handlers/v0 · high confidence

Shell integration scripts are bundled in the source tree

The shell initialization scripts for Bash, Fish, Nushell, PowerShell, Xonsh, and Zsh are now included directly in the \crates/atuin/src/shell\ directory. This change ensures that the correct versions of these scripts are always available for users to source, replacing any previous reliance on external or dynamically generated files. The scripts include updated logic for session management, history recording, and prompt integration across all supported shells.

crates/atuin/src/shell · high confidence

Shell-specific dotfile configuration generation for Bash, Fish, PowerShell, Xonsh, and Zsh

Atuin now generates shell-specific configuration files for aliases and environment variables, supporting Bash, Fish, PowerShell, Xonsh, and Zsh. Each shell module provides functions to read cached configurations or generate them on the fly, ensuring that shell startup is not prevented even if Atuin fails to generate the config. PowerShell support includes specific handling for aliases with implicit arguments and secure command execution via Invoke-Expression.

crates/atuin-dotfiles/src/shell · high confidence

Support for syncing and exporting shell environment variables

The dotfiles store now includes a dedicated module for managing shell environment variables, allowing users to sync their env vars across devices. This change introduces a \VarStore\ that handles the creation and deletion of variable records, and provides methods to export these variables in formats compatible with POSIX shells (bash, zsh), Fish, Xonsh, and PowerShell, ensuring proper escaping of special characters for each environment.

crates/atuin-dotfiles/src/store · high confidence

Removals

Removal of legacy CLI entry point

The original \src/main.rs\ file, which implemented the initial command-line interface for the 'Shync' tool using Clap and a local SQLite database, has been deleted. This change removes the legacy codebase that handled basic history management (add, list) and server initialization, indicating a significant architectural shift or replacement of the application's core entry logic.

src · high confidence

Removed local SQLite history storage implementation

The local history storage mechanism using SQLite has been removed from the application. The \SqliteDatabase\ struct and its associated \Database\ trait, which handled saving and listing history records to a local SQLite file, have been deleted along with the \History\ data structure definition. This indicates a shift away from the previous local-only, synchronous SQLite-based persistence model.

src/local · high confidence

Behavioural changes

Agent hook events now support string-only tool responses

The hook command's wire protocol has been updated to accept \tool\_response\ payloads that are simple strings (e.g., from Codex), in addition to the previous object format containing an \exitCode\. This ensures that agent hook events with string-based responses are correctly parsed and processed without errors, while maintaining support for structured response objects.

crates/atuin/src/command/client/hook · high confidence

Atuin crate structure reorganization and build configuration

The atuin crate has been reorganized into the crates/ directory, with documentation files (README, CHANGELOG) converted to symlinks pointing to the project root. A new build script (build.rs) was added to capture the current Git commit hash at compile time, and an internationalization configuration file (i18n.toml) was introduced to set up Fluent-based localization with English as the fallback language.

crates/atuin · high confidence

Daemon service management refactored with platform-specific backends

The daemon's startup and lifecycle are now managed through a unified backend system that adapts to the operating system. On macOS, the daemon can run as a launchd agent, allowing launchd to hold the Unix socket and restart the daemon automatically. On other systems, it falls back to forking a background process (Subproc) or integrating with external service managers like systemd (External). This change also introduces a dedicated address module that handles platform-specific connection logic (Unix sockets on Unix, TCP on Windows) and improves socket file management to prevent conflicts with stale sockets or other programs.

crates/atuin-daemon/src/service · high confidence

Daemon sync engine refactored with resilient retry and AI session support

The daemon's cloud synchronization logic has been replaced with a standalone background engine that manages periodic syncing of local history and search index updates. This new implementation introduces a persistent exponential backoff strategy for failed sync attempts, ensuring that retries continue indefinitely until success without resetting the backoff ramp or abandoning the operation. Additionally, the engine now integrates support for AI agent sessions, including a background projector that handles the synchronization and reprojection of AI session records into the sidecar store.

crates/atuin-daemon/src/sync · high confidence

Database password can be loaded from a file and new usernames are validated

Server administrators can now provide a \db\_password\_file\ in the database settings to load the database password from a file instead of embedding it in the connection URI, which improves security by avoiding password exposure in configuration files or process listings. Additionally, when creating new user accounts, usernames are now strictly validated to contain only ASCII letters, digits, and hyphens, ensuring consistency and preventing invalid characters in new registrations.

crates/atuin-server/src/db · high confidence

Localized UI text and improved error display for sync failures

User-facing strings are now localized using Fluent, with the application detecting the system locale via standard environment variables. Additionally, sync errors—specifically wrong encryption key issues—now display a prominent, colored banner with clear instructions on how to resolve the key mismatch, rather than a plain error message.

crates/atuin/src · high confidence

Migrate CI to Buildkite with optimized test splitting and caching

The project has moved its continuous integration from GitHub Actions to Buildkite, introducing a suite of scripts to manage the new pipeline. Test execution is now optimized by compiling tests once and splitting them across parallel jobs based on historical timing data via the Buildkite Test Engine. The pipeline also features smarter caching strategies that avoid redundant uploads for unchanged subtrees and includes dedicated steps for running integration tests against Postgres, validating the installer, and performing static analysis with Shellcheck and Vale.

.buildkite/scripts · high confidence

The output capture subsystem has been restructured into a persistence layer that stores captured command output in a Fjall key-value store and maintains a separate SQLite FTS5 index for full-text search. This change introduces a garbage collector to automatically evict old entries when disk usage exceeds a configured budget, and a background reconciler to keep the search index in sync with the blob store. The system gracefully degrades to a no-op mode if either the storage or index backend fails to open, ensuring that capture continues even if search is unavailable.

_crates/atuin-daemon/src/output\capture/persistence · high confidence

PostgreSQL minimum version requirement raised to 14

The server's PostgreSQL database implementation now enforces a minimum version of 14, rejecting connections to older servers. This change is part of a broader refactoring that consolidates database logic and updates schema migrations, including the removal of legacy email verification tables and the history count trigger.

crates/atuin-server/src/db/postgres, crates/atuin-server/src/db/sqlite · high confidence

Search engine architecture refactored to support daemon-based and database-backed search modes

The search subsystem has been restructured to introduce a new \daemon.rs\ engine that communicates with the Atuin daemon for in-memory, ranked search, and a \db.rs\ engine that handles local SQLite queries. The daemon engine automatically attempts to start the daemon if it is not running and includes logic to fall back to the database search for regex patterns or when the daemon is unavailable. The database engine now explicitly supports different search modes (such as FullText and Prefix) and provides specific highlighting logic for full-text matches, replacing the previous unified fuzzy-search approach.

crates/atuin/src/command/client/search/engines · high confidence

Shell init scripts now support tmux popups, AI, and unique keybinding names

The \atuin init\ command has been refactored to generate shell initialization scripts that support tmux popups (configuring width/height for Bash, Fish, and Zsh), optional AI integration (enabled via the \ai\ feature for Bash, Fish, and Zsh), and unique keybinding names in Nushell to prevent conflicts. The init logic also respects the \ATUIN\_NOBIND\ environment variable to disable keybindings and includes a bash-preexec loader for Bash when no other preexec backend is present.

crates/atuin/src/command/client/init · high confidence

Strict version matching for daemon-client communication

The daemon now enforces strict version compatibility by exchanging build identifiers (version plus commit SHA) via the \x-atuin-build\ HTTP header on every request and response. If the client and daemon versions do not match exactly, the daemon refuses the request before processing it, preventing wire-incompatible interactions. This ensures that clients and daemons only communicate when they are from the same build, with \Status\ and \Shutdown\ RPCs serving as the mechanism to detect and replace mismatched daemons.

crates/atuin-daemon/src/grpc · high confidence

Sync status command now requires login and uses localized text

The \atuin status\ command (specifically the sync status view) now exits with an error if the user is not logged in, rather than potentially displaying incomplete or misleading information. Additionally, all user-facing text in this command has been localized using Fluent, ensuring consistent language support across the interface.

crates/atuin/src/command/client/sync · high confidence

Unified database backend with dialect-aware SQL and eager connection validation

The server's database layer has been refactored to use a single, polymorphic \Database\ trait backed by \DynDatabase\, allowing Postgres, MySQL, and SQLite to share a common interface while handling their specific SQL dialects (ordinal vs. positional binding) via a \Dialect\ abstraction. This change introduces eager connection validation, ensuring that a misconfigured \db\_uri\ fails immediately at startup rather than later during operation, and standardizes migration execution across all supported backends.

crates/atuin-server/src/db/mysql · high confidence

Unified server configuration and build setup

The atuin-server crate now includes a dedicated \server.toml\ configuration file that allows users to specify database connection URIs for PostgreSQL, SQLite, or MySQL, along with settings for host, port, registration policies, and record size limits. A new \build.rs\ script ensures that database migrations for all three supported backends are tracked for rebuilds, and a symlinked changelog is in place to ensure distribution tools can locate the changelog file.

crates/atuin-server · high confidence

Vendored axoasset library and bash-preexec hook for installation and shell integration

The vendor directory now includes the axoasset Rust library (v2.0.1) and the bash-preexec script. The axoasset vendoring fixes installation from crates.io by bundling the library directly, ensuring consistent builds. The bash-preexec integration automatically loads the hook if no other preexec backend is present, enabling shell command tracking.

vendor · high confidence

Fixes

The file at crates/atuin/vendor/bash-preexec was previously missing or incorrect, preventing proper installation from crates.io. This change restores the correct symbolic link pointing to the actual bash-preexec source code, ensuring the dependency is correctly resolved during build and installation.

crates/atuin/vendor · high confidence

Test coverage

Add benchmarks and AI session capture infrastructure; Added integration tests for server database operations, sync, and user management; Added server test infrastructure for integration testing; Added test harness and corpus for daemon integration tests; Adopt proptest and rstest for daemon test suites; End-to-end test suite for shell integration, daemon, and AI sessions; New e2e test harness for AI session capture and shell integration.

Dependencies

Workspace dependency management and Rust 2024 edition migration

The project has migrated to the Rust 2024 edition and restructured its dependency management by lifting common dependencies into the top-level workspace \Cargo.toml\. This change standardizes versioning across all crates—including \atuin\, \atuin-client\, \atuin-daemon\, and \atuin-ai\—ensuring consistent dependency resolution and reducing maintenance overhead. The update also includes a comprehensive refresh of the dependency tree, updating core libraries such as \tokio\, \clap\, \sqlx\, and \ratatui\ to their latest versions, which improves performance, stability, and compatibility with the new Rust edition.

(dependencies) · high confidence

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

How this codebase got here

Score

  • CAI 60 → 57 (-3.0)

Lenses

  • Code Health 54 → 47 (-7.1)
  • Architecture 94 → 92 (-1.4)
  • Maturity 59 → 63 (+3.9)
  • Readiness 63 → 61 (-1.2)
  • Security 59 → 58 (-1.1)
  • Domain Modelling 100 → 100 (+0.0)
  • Event Sourcing 100 → 100 (+0.0)
  • Performance 91 → 100 (+8.6)

Resolved (47)

  • AtuinAiSessionReadToolCall::render (cognitive 38) (crates/atuin-ai/src/tools/session/read.rs)
  • AtuinAiSessionReadToolCall::render (cyclomatic 26) (crates/atuin-ai/src/tools/session/read.rs)
  • AtuinAiSessionSearchToolCall::run (cognitive 16) (crates/atuin-ai/src/tools/session/search.rs)
  • Documentation: contradicts the code (docs/docs/ai/command-output.md)
  • Duplicated block (10 lines × 2) (crates/atuin-ai/src/resume_tui/render.rs)
  • Duplicated block (10 lines × 2) (crates/atuin-client/src/import/xonsh.rs)
  • Duplicated block (10 lines × 5) (crates/atuin-dotfiles/src/shell/bash.rs)
  • Duplicated block (11 lines × 2) (crates/atuin-client/src/import/nu.rs)
  • Duplicated block (11–12 lines × 2) (crates/atuin/src/command/client/account/login.rs)
  • Duplicated block (13 lines × 2) (crates/atuin-common/src/harnesstools/ccode/session.rs)
  • Duplicated block (14 lines × 3) (crates/atuin-daemon/src/client.rs)
  • Duplicated block (17 lines × 3) (crates/atuin-daemon/src/client.rs)
  • Duplicated block (9 lines × 2) (crates/atuin-common/src/harnesstools/ccode/rehydrate.rs)
  • FunctionTooLong: atuin_common::harnesstools::continuation::turns (crates/atuin-common/src/harnesstools/continuation.rs)
  • Hotspot: crates/atuin-daemon/src/server.rs (crates/atuin-daemon/src/server.rs)
  • Hotspot: crates/atuin/src/command/client/import.rs (crates/atuin/src/command/client/import.rs)
  • Inconsistent naming for deletion operations. Sqlite uses delete for a single entity and delete_rows for multiple IDs. SqliteStore uses delete for a single entity and delete_all for clearing everything. There is no delete_batch or delete_ids in SqliteStore to match Sqlite.delete_rows, and Sqlite lacks a bulk delete by ID method that matches SqliteStore's single-item delete signature style.
  • Inconsistent naming for read/retrieval operations. Sqlite uses load for fetching a single entity by ID, while SqliteStore uses get. Additionally, SqliteStore exposes first and last for boundary retrieval, whereas Sqlite uses last but lacks a corresponding first (it has range or before).
  • Low cohesion: Settings (LCOM4 8) (crates/atuin-client/src/settings.rs)
  • Members sharing a duplicated core (5 members, 50+ identical tokens) (crates/atuin-dotfiles/src/shell/bash.rs)
  • …and 27 more

New (78)

  • AiSessionStore::reproject_series (cyclomatic 16) (crates/atuin-client/src/ai_session/store.rs)
  • AtuinThreadsReadToolCall::render (cognitive 38) (crates/atuin-ai/src/tools/session/read.rs)
  • AtuinThreadsReadToolCall::render (cyclomatic 26) (crates/atuin-ai/src/tools/session/read.rs)
  • AtuinThreadsSearchToolCall::run (cognitive 16) (crates/atuin-ai/src/tools/session/search.rs)
  • Change coupling: client.rs ↔ server.rs (crates/atuin-daemon/src/client.rs)
  • Duplicated block (10 lines × 5) (crates/atuin-dotfiles/src/shell/bash.rs)
  • Duplicated block (11 lines × 2) (crates/atuin-client/src/import/nu.rs)
  • Duplicated block (11–12 lines × 2) (crates/atuin/src/command/client/account/login.rs)
  • Duplicated block (5 lines × 2) (crates/atuin-daemon/src/service/backend/launchd/macos.rs)
  • Duplicated block (6 lines × 2) (crates/atuin-client/src/import/xonsh.rs)
  • Duplicated block (6 lines × 2) (crates/atuin-common/src/db/sqlite/fts.rs)
  • Duplicated block (7 lines × 2) (crates/atuin-common/src/harnesstools/ccode/rehydrate.rs)
  • Duplicated block (9 lines × 2) (crates/atuin-common/src/harnesstools/ccode/rehydrate.rs)
  • FileTooLong: pi/session.rs (crates/atuin-common/src/harnesstools/pi/session.rs)
  • FunctionTooLong: atuin_daemon::boot (crates/atuin-daemon/src/lib.rs)
  • FunctionTooLong: atuin_pty_proxy::runtime::run (crates/atuin-pty-proxy/src/runtime.rs)
  • High secret: WD-SECRET-0005 (.env)
  • High secret: WD-SECRET-0005 (atuin/src/command/client/account/change_password.rs)
  • High secret: WD-SECRET-0005 (atuin/src/command/client/account/change_password.rs)
  • High secret: WD-SECRET-0005 (crates/atuin/src/command/client/account/change_password.rs)
  • …and 58 more

Changes since last survey

  • 102 commits — 64 feature/other, 38 fixes

By area

  • crates/atuin — 20 commits
  • (root) — 15 commits
  • crates/atuin-common — 15 commits
  • crates/atuin-ai — 13 commits
  • crates/atuin-daemon — 12 commits
  • crates/atuin-client — 9 commits
  • crates/atuin-pty-proxy — 6 commits
  • docs/docs — 5 commits
  • crates/atuin-server — 2 commits
  • .buildkite/cache.yml — 1 commit
  • .buildkite/pipeline.yml — 1 commit
  • .github/workflows — 1 commit
  • crates/atuin-scripts — 1 commit
  • docs/uv.lock — 1 commit

Notable commits

  • fix: Fix server environment variables overriding server.toml (atuinsh/atuin#4456)
  • fix: fix(ai): correct large-file read guidance (atuinsh/atuin#4355)
  • fix: fix(ai): fit the resume picker's title to the version so a prerelease isn't cut off (atuinsh/atuin#4406)
  • fix: fix(ai): import IntoStaticStr from strum_macros, not strum (atuinsh/atuin#4480)
  • fix: fix(ai): improve detection of git repositories (atuinsh/atuin#4450)
  • fix: fix(ai): only look up repos for this host's sessions in the resume picker (atuinsh/atuin#4400)
  • fix: fix(ai-session): fix opencode 1.x resume capture, A→B→A catch-up, synced tail, and picker tty, keys and idle CPU (atuinsh/atuin#4398)
  • fix: fix(ai-session): switch inside a merged run past a failed call without losing the run's earlier text (atuinsh/atuin#4402)
  • fix: fix(client): keep the logging guard alive until the command finishes (atuinsh/atuin#4528)
  • fix: fix(client): resolve relative config paths beside config.toml, not the cwd (atuinsh/atuin#4479)
  • fix: fix(config): avoid shadowing data dir, fix gaps in avoidance logic (atuinsh/atuin#4421)
  • fix: fix(config): don't let a default ~/.atuin/config.toml hide the legacy config, and warn when one does (atuinsh/atuin#4420)
  • fix: fix(config): don't print errors twice (atuinsh/atuin#4501)
  • fix: fix(config): let ATUIN_* environment variables override config.toml (atuinsh/atuin#4438)
  • fix: fix(daemon): fetch the server's capabilities until a fetch succeeds
  • fix: fix(daemon): handle daemons not spawned by atuin (atuinsh/atuin#4516)
  • fix: fix(daemon): spare a stale pidfile's PID when evicting (atuinsh/atuin#4512)
  • fix: fix(daemon): verify daemon version in HTTP headers (atuinsh/atuin#4431)
  • fix: fix(deps): bump ctutils and tokio for RUSTSEC-2026-0385 and -0386 (atuinsh/atuin#4525)
  • fix: fix(docker): ship patched ca-certificates in the server image (atuinsh/atuin#4522)
  • …and 82 more

Architecture

  • Unchanged — 0 containers · 1 contexts · 0 edges

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

Survey your own repository

atuinsh/atuin 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.

About this page

  • The score is its most recent published measurement, taken on 26 October 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
  • Measured at commit fbbb4864851dbe832d966afc69c25ddd4de4400c — the exact code this score is about.
  • Scored under rubric-2026.10.5 — the same rubric and the same method as every other entry in this index.
  • Measured by watchdog.canine.dev using codehealth-analyzer measure-2026.10.31+preprod-85beac5a16f3.