atomic

Package bundlemirror implements the artifact mirror logic behind internal/tools/bundle-mirror, split out so it is testable without main().

Package bundlespec holds the bundle inclusion predicates, shared by bundlemirror at build time and manifestcheck at runtime so the two cannot disagree about what ships.

Package bus implements atomic bus: a per-user daemon behind a Unix domain socket that lets concurrent Claude Code sessions on one machine message each other over named rooms.

Package claudeinstall writes the embedded artifact bundle to a target directory (default ~/.claude) and manages backups for changed files.

Package cliusage exposes the atomic command surface as data, so the validate artifacts rule can check citations against the same tree Cobra renders help from.

Package cliutil provides shared utilities for the atomic CLI.

Package cli implements the `atomic code` subcommand handlers.

Package codectx turns a natural-language query into an agent-ready snapshot of the relevant portion of the code graph.

Package db opens and initialises the code-intelligence SQLite database.

Package engine is the facade both the `atomic code` CLI and the MCP server compile against.

Package extraction provides the parser-pool runtime over tsbinding (tree-sitter via wazero).

Package languages provides per-grammar LanguageExtractor configurations.

Package standalone provides extractors for file formats the tree-sitter pipeline does not handle: Vue SFC, Svelte, Liquid, Delphi DFM, MyBatis XML, and SQL.

Package graph traverses the resolved code-intelligence graph.

Daemon lifecycle: a per-project unix socket serving MCP over each accepted connection, with an idle reaper and auto-shutdown.

Package realm resolves repo-versus-realm scope from the process cwd, so no user flag is needed to locate the right db.

Package resolution turns unresolved references into graph edges: imports to their target files, names to their declarations, and — via the synthesis subpackage — dynamic dispatch the source never states outright.

Phoenix (Elixir) router resolver.

Package synthesis infers dynamic-dispatch edges that static extraction cannot see — a setState call reaching render, an emit reaching its listener, an interface method reaching its implementation.

Package search ranks code-graph nodes through three tiers, each firing only when the one before it returned nothing: FTS5, case-insensitive LIKE, then bounded Damerau-Levenshtein fuzzy matching.

Package types is the shared data contract every engine layer depends on, and the only engine package it may depend on in turn.

Package coldprompt serves the brief texts behind `atomic prompt <name>`: self-contained instructions for a subagent starting with no accumulated context.

Package config manages atomic's TOML-backed configuration under ~/.atomic/: lenient load, strict write validation, get/set/unset, atomic file writes, and a markdown render of resolved values.

Package dockerinit scaffolds the Docker eval environment: four rendered templates plus the bind-mount placeholder directories docker-compose expects.

Package docs writes a doc-surfaces cache under config.ProjectDir: every discovered .md file with its H1 and first three H2 headings, so the signals workflow can index the documentation without loading it.

Package doctemplate serves the fill-in document skeletons behind `atomic template <name>`.

Package doctor implements the `atomic doctor` subcommand: a deterministic integrity check for atomic-claude install + project state coherence.

Package embedded holds the artifact bundle embedded at build time.

Package followups parses and renders the per-entry frontmatter markdown files under the project followups dir, plus the CLOSED.md ledger.

Package frontmatter parses and emits YAML frontmatter in markdown files.

Package hooks builds the Claude Code session-start payload and manages its settings.json registration.

Package manifestcheck compares the committed embedded manifest against what bundlemirror would generate from the live repo root, writing nothing.

Package mdlink rewrites inline-code path tokens in markdown prose into relative markdown links, when the token resolves under a given base directory.

Package mdparse provides goldmark-based helpers for inspecting markdown structure, used by the atomic-validate spec and config validators.

Package migrate applies versioned, replayable migration steps in ascending semver order, comparing versions via selfupdate.CompareSemver.

Package profile captures deterministic environment data and renders the profile.md stub written at install time.

Package prompt wraps charmbracelet/huh to provide interactive prompts with TTY detection and a testable internal seam.

Package reminder manages frontmatter markdown reminders under .claude/.scratchpad/reminders/.

Package repl implements atomic repl: named, persistent Python and Node interpreter sessions an agent drives across separate Bash calls.

Package repoctx resolves the working root for the current invocation.

Package repoinit scaffolds the .claude/ layout and its ignore rules.

Package scratchpad owns creation, lookup, listing, and archival of one slug-keyed bundle per unit of work — the state `atomic-plan`, `subagent-implementation`, `quick-fix`, `subagent-diagnose`, and `challenge-swarm` each carry across their own run.

Package selfupdate implements foreground and background self-update logic for the atomic binary.

/api/bus/*: a web chat client over the atomic bus daemon, so the UI can watch rooms and speak into one as a human member.

Package signals scans a repo into the deterministic substrate document.

Package templaterender expands the {{ template "<name>" .

bundle-mirror copies the artifact bundle into atomic/internal/embedded/ so the embed directive can reach it, and writes manifest.go with the allowlist.

Package updatedoctor runs a scoped doctor check after a successful self-update.

This file holds the shared Finding type and the ordering and counting helpers every rule runner depends on.

Package version exposes the binary version and commit SHA, both stamped at build time via -ldflags -X and defaulting to "dev" / "unknown".

Package where implements the `atomic where` orientation verb, reporting a cwd's position across four orthogonal axes: repo root, repo-scope wiki, realm scope, and code-index scope.

Package wiki implements the deterministic core of the atomic wiki feature: repo discovery, classification, scaffold creation, and idempotent <wiki-scan> block writes.