A SNOWBROS product · v0.1 · Open source

Same code in.
Same findings out.

Snowbros Atlas maps your whole JavaScript/TypeScript project and reports problems it can prove — circular imports, dead files, Next.js server/client leaks, unused dependencies, secrets. Native Rust, with the evidence attached.

View on GitHub Read the docsnpx snowbros analyze

Open SourceRustCLIVS Code

sb analyze finds a server-only leak, a circular import, and a hardcoded secret — health 93 of 100

// why atlas

Per-file linters can’t see project structure. Atlas can.

Deterministic by construction

No AI, no timestamps, no network. Same code and config in, same findings out — the warm-cache run is byte-identical to a cold one, enforced by tests.

Milliseconds, not minutes

A native Rust binary with an incremental cache: ~270 ms cold and ~34 ms after a one-file change on a 500-file repo. Fast enough to run on every save.

Evidence, not vibes

Every finding carries the chain that produced it and a confidence level. Anything the resolver can't prove is labeled unresolved — never guessed.

Whole-project graph

A semantic import graph with cycle detection and dead-file reachability — the structural problems that are invisible to per-file linters.

Meets you everywhere

Terminal, JSON, SARIF for GitHub code scanning, self-contained HTML, a health scorecard, a built-in LSP, and a first-party VS Code extension.

Fixes it can prove

sb fix applies guarded, idempotent edits for unused deps and env vars. Files that drifted since analysis are skipped, never clobbered.

// how it works

One deterministic pipeline, cache-accelerated.

scan

ignore-aware walk

parse

Tree-sitter · cached

facts

imports · exports · env

resolve

tsconfig · aliases

graph

SCC · reachability

rules

evidence-first

report

+ scorecard

Warm output is byte-identical to a cold run — the cache can skip work, never change results. Read the architecture →

// how it compares

Run it alongside your linter, not instead of it.

Capability	Atlas	ESLint	Knip	dep-cruiser
Whole-project semantic graph	Yes	Per-file	Partial	Yes
Circular imports (cycle listed)	Yes	Plugin	No	Yes
Dead files / unused exports	Yes	No	Yes	Partial
Next.js server/client boundary	Yes	Partial	No	No
Deterministic, evidence-first	Yes	Mostly	Mostly	Mostly
SARIF · LSP · watch · scorecard	Yes	LSP only	No	No
Runtime	Native	Node	Node	Node

// install

One line to try it. No account, no config.

npm — no install needed

npx snowbros analyze

Homebrew (macOS, Linux)

brew install snowbros-labs/tap/snowbros-atlas

Cargo

cargo install snowbros-atlas --locked

Shell (macOS, Linux)

curl -LsSf https://github.com/snowbros-labs/atlas/releases/latest/download/snowbros-atlas-installer.sh | sh

// in your editor

First-class VS Code support.

The extension wraps the built-in language server, so findings stream into native diagnostics as you save — severities mapped to Errors, Warnings, Hints, with click-to-navigate. Analyze, explain a rule, open an HTML report, or check the health score without leaving the editor.

Extension docs Other editors (LSP)

Snowbros Atlas HTML report — a health scorecard and findings with evidence

// performance

Fast enough to run on every save.

Measured on real repositories (zod, axios, fastify). See the dogfood reports →

// roadmap

Where Atlas is going.

Now

package.json main/exports resolution
Monorepo / workspace awareness
VS Code Marketplace publish

More rules, driven by real reports
Rule maturity gating (nursery)
Wider auto-fix coverage

Later

Pattern rule engine (no Rust)
OSV vulnerability data
A second language family

Full roadmap →

// faq

Questions, answered.

Is it a linter? Do I replace ESLint or Biome?

No. Atlas works one layer up, on whole-project structure — the import graph, framework boundaries, and manifest. Run it alongside your linter, not instead of it.

Does it use AI?

No. Atlas is deterministic by design: the same codebase and config always produce the same findings, each backed by an evidence chain. No model decides whether an issue exists.

Which languages are supported?

Deep analysis covers the JavaScript/TypeScript family (.js/.jsx/.ts/.tsx and their .mjs/.cjs variants). Other languages are detected for context; more are on the roadmap.

Will it slow down or break my CI?

It is native-fast, and `sb analyze --ci` is a single exit-code gate. Because Atlas finds more over time, pin the version and use snowbros.toml thresholds to control what fails the build.

Map your project in one command.

Try it on your repo right now — then star it, break it, and tell us where it’s wrong.

Star on GitHub See real-world runs

Same code in.Same findings out.