Ignore Patterns

Atlas uses glob patterns to skip files that shouldn’t be tracked — secrets, build artifacts, system files, and editor temporaries. Ignored files are never hashed or recorded.

Viewing Patterns

atlas ignore list
atlas ignore list --json    # Machine-readable output

Output shows each pattern, its reason, and source:

Ignore patterns:

  [default] *.env — May contain secrets or API keys
  [default] .ssh/* — SSH keys and configuration
  [default] target/* — Build artifacts
  [pack]    *.reapeaks — Reaper peak cache file
  [custom]  *.db — Database files
  [disabled] *.log — Log files
  [~/projects/myapp] dist/* — Build output

Tags indicate pattern source:

[default] — Built-in, cannot be removed
[pack] — Registered by an extractor pack, cannot be removed
[custom] — User-added
[disabled] — Toggled off (not currently active)
[~/path] — Scoped to a specific directory

Filtering by Scope

Show only patterns effective at a specific directory:

atlas ignore list --scope ~/projects/myapp

This shows all global patterns plus any patterns scoped to that directory or its ancestors.

Adding Patterns

atlas ignore add "*.tmp"
atlas ignore add "*.db" --reason "Local database caches"

Patterns use glob syntax. The --reason flag is optional (defaults to “User-defined”).

Directory-Scoped Patterns

Scope a pattern to a specific directory so it only applies there:

atlas ignore add "dist/*" --scope ~/projects/myapp --reason "Build output"
atlas ignore add ".venv/*" --scope ~/projects/api --reason "Python virtualenv"

Scoped patterns are additive only — they can ignore more files within a directory but can never override global defaults. The same pattern can be scoped to multiple directories independently.

Any subdirectory within a watched tree is a valid scope. Atlas warns if the scope path isn’t within any watched directory.

All scope data is stored in the database — Atlas never creates files in your watched directories.

Removing Patterns

atlas ignore remove "*.tmp"
atlas ignore remove "dist/*" --scope ~/projects/myapp

Only custom patterns can be removed. Default and pack-registered patterns are permanent — they protect sensitive files from accidental tracking.

When removing a scoped pattern, specify the --scope to target the correct rule.

Enabling and Disabling Patterns

Toggle a pattern on or off without deleting it:

atlas ignore disable "*.log"
atlas ignore enable "*.log"

Disabling a pattern stops it from being applied — files matching the pattern will start being tracked on the next scan. The pattern stays in the database for easy re-enabling.

Sensitive Pattern Protection

Disabling a pattern that protects sensitive files (secrets, credentials, keys) requires explicit confirmation:

atlas ignore disable "*.env"
# Warning: '*.env' protects sensitive files (May contain secrets or API keys).
# Disabling this pattern will allow Atlas to track matching files.
# To confirm, re-run with: atlas ignore disable "*.env" --confirm

atlas ignore disable "*.env" --confirm

Re-enable Hint

When re-enabling a pattern, Atlas checks if matching entities already exist in the database and suggests cleanup:

Enabled ignore pattern: *.log
Note: 47 entities matching this pattern exist in the database.
Run 'atlas forget --pattern "*.log"' to remove them.

Scoped Toggle

Enable/disable works with scoped patterns too:

atlas ignore disable "dist/*" --scope ~/projects/myapp
atlas ignore enable "dist/*" --scope ~/projects/myapp

Pattern Matching

Patterns use glob syntax and match against both the full file path and the filename:

Pattern	Matches
`*.env`	Any file ending in `.env`
`.env.*`	`.env.local`, `.env.production`, etc.
`.ssh/*`	Anything inside a `.ssh` directory
`credentials`	Any file with “credentials” anywhere in the name
`target/*`	Anything inside a `target` directory
`dist/*`	Anything inside a `dist` directory

Pattern Precedence

The effective ignore set for a file is the union of all matching enabled patterns:

Global defaults (floor, non-overridable)
  + Pack-registered patterns
  + User custom global patterns
  + Directory-scoped patterns (additive only)

Each layer can only add patterns, never subtract from a previous layer. A scoped pattern cannot allowlist something a global default blocks.

Default Patterns

Atlas ships with 31 default ignore patterns across four categories.

Secrets & Credentials

Pattern	Reason
`*.env`	May contain secrets or API keys
`.env.*`	May contain secrets or API keys
`*.key`	May contain cryptographic keys
`*.pem`	May contain certificates or keys
`*.p12`	May contain certificates or keys
`*.pfx`	May contain certificates or keys
`*.keystore`	Java keystore — may contain keys
`*.jks`	Java keystore — may contain keys
`.ssh/*`	SSH keys and configuration
`id_rsa`	SSH private keys
`id_ed25519`	SSH private keys
`*.secret`	May contain secrets
`credentials`	May contain credentials
`password`	May contain passwords
`*.token`	May contain auth tokens
`.gnupg/*`	GPG private keys
`.aws/*`	AWS credentials and config
`.docker/config.json`	Docker registry auth
`.npmrc`	npm auth tokens
`.pypirc`	PyPI credentials
`.netrc`	Network credentials

VCS & Build Artifacts

Pattern	Reason
`.git/*`	Git internal files
`node_modules/*`	Package manager cache
`target/*`	Build artifacts
`__pycache__/*`	Python bytecode cache
`*.pyc`	Python bytecode

System Files

Pattern	Reason
`.DS_Store`	macOS system file
`Thumbs.db`	Windows system file

Editor Temporaries

Pattern	Reason
`.sb-`	macOS editor scratch file
`*~`	Editor backup file
`*.swp`	Vim swap file
`*.swo`	Vim swap file
`.*.swp`	Vim swap file
`.*.swo`	Vim swap file

Pack-Registered

Extractor packs can register additional default patterns. The audio pack includes:

Pattern	Reason
`*.reapeaks`	Reaper peak cache file