How does Atlas run `bun test`?

Atlas uses its `bash` tool to execute `bun test` commands directly, just as you would in your terminal. This allows it to leverage all native `bun test` flags, such as `--filter` for isolating specific tests or `--verbose` for detailed output, providing a familiar debugging experience.

Can Atlas debug a failing test in a large Bun project?

Yes, Atlas is designed for large projects. It indexes code by AST declarations using Tree-sitter, not blind line windows, and uses hybrid semantic and keyword retrieval, making it efficient for navigating and understanding extensive Bun codebases, even in 2026.

What if Atlas suggests fixing the test assertion instead of the code?

Atlas is specifically instructed to find why a test fails and fix the *code*, not the assertion. Its workflow focuses on walking the call graph with the `lsp` tool and identifying the root cause in the production logic, ensuring a practical option.

How does Atlas ensure code quality after a fix in Bun?

After proposing a fix, Atlas can run `bun fmt` over the generated diff before you approve the commit. This ensures that any changes adhere to your project's formatting standards, maintaining code consistency and simplifying subsequent code reviews.

Is my Bun code safe when Atlas is making changes?

Yes, Atlas prioritizes safety. Every tool call is permission-gated against allow, ask, and deny rules, and all proposed code edits are presented as a unified diff for your explicit approval before any changes are written to disk. Atlas also snapshots file changes as git patches for easy rollback.

Can Atlas use my local Ollama embeddings for Bun code?

Yes, Atlas can build its code index with local Ollama embeddings, ensuring that your Bun project's code remains off third-party servers and is processed securely within your local environment. This provides enhanced privacy and control over your codebase.

How does Atlas handle complex Bun API usage during debugging?

Atlas is designed to read and understand Bun-native APIs like `Bun.serve`, `Bun.file`, and `bun:sqlite`. This allows it to accurately interpret and debug code that leverages Bun's specific features and idioms, providing relevant insights for complex Bun applications.

Debug a Single Failing Test in Bun with Atlas in 2026

Atlas helps Bun developers debug a single failing test by running `bun test` in isolation, analyzing the assertion and call graph, and then proposing precise code fixes. This process leverages Atlas's `bash` tool to execute Bun's native test runner, ensuring a familiar and efficient debugging experience within your terminal environment.

How Atlas Debugs a Single Failing Test in Bun

Atlas debugs a single failing test in Bun by first executing `bun test` with a specific filter, isolating the problem to a single test case. This focused approach, available in 2026, ensures that Atlas receives minimal output, allowing it to quickly identify the assertion failure and the exact code path involved.

Atlas initiates the debugging workflow by using its `bash` tool to run `bun test` with a `--filter` flag, targeting only the failing test. This immediate isolation is crucial for efficiency, as Bun's test runner is exceptionally fast. Once the test output is captured, Atlas employs its `read` tool to analyze the assertion message and the surrounding code. Subsequently, Atlas utilizes its `lsp` tool to perform `goToDefinition` and `findReferences` operations, meticulously tracing the call graph from the failing test back to the production code it exercises. This deep understanding of the code's execution path allows Atlas to form a precise hypothesis about the bug. Atlas can then check this hypothesis by adding temporary logging with its `edit` tool or re-running the test with a verbose flag through `bash`, iterating rapidly thanks to Bun's near-instant iteration speeds.

Executing `bun test` with Atlas's Bash Tool

Atlas leverages its `bash` tool to run `bun test` directly, mirroring how a Bun developer would execute tests in their terminal. This integration means all standard `bun test` flags, like `--filter` or `--verbose`, are fully supported, providing a familiar and powerful debugging environment in 2026.

The `bash` tool within Atlas is fundamental to its interaction with Bun projects. When debugging a single failing test, Atlas constructs and executes a command such as `bun test --filter "MyFailingTest"`. This direct execution ensures that Atlas operates within the exact same environment and with the same capabilities as a human developer. The output from `bun test` is then captured and processed by Atlas, allowing it to parse error messages, stack traces, and any temporary logging added during the debugging process. This approach not only makes Atlas's actions transparent but also allows developers to guide Atlas using their existing knowledge of `bun test` commands and flags, such as enabling verbose output for more detailed insights into test failures.

Navigating Bun Code with Atlas's LSP Tool

After identifying a failing test, Atlas uses its `lsp` tool to work through the Bun codebase, tracing the call graph from the test to the production code. This allows Atlas to perform `goToDefinition` and `findReferences` operations, understanding the code's structure and dependencies with 100% accuracy.

Atlas's `lsp` tool is critical for understanding the intricate relationships within a Bun project's codebase. Once a failing test is isolated and its assertion understood, Atlas uses `lsp` to jump from the test file to the definition of the function or module it's testing. For example, if `test/my-feature.test.ts` fails, Atlas can use `goToDefinition` to navigate to `src/my-feature.ts`. From there, it can use `findReferences` to see all other locations where the problematic code is used, helping to identify potential side effects or shared dependencies. This capability, powered by Tree-sitter for AST declarations, allows Atlas to build a comprehensive mental model of the code's structure, which is essential for forming accurate hypotheses about the root cause of a bug and proposing effective fixes.

Fixing Bun Code and Ensuring Quality with Atlas

Atlas fixes the production code in Bun projects using its `edit` or `apply_patch` tools, ensuring changes are precise and targeted. Before committing, Atlas can automatically run `bun fmt` over the diff, maintaining code style and quality standards for your project in 2026.

Once Atlas has formed a hypothesis and verified it, it proceeds to fix the production code. For minor, localized changes, Atlas uses its `edit` tool to modify specific lines or blocks of code. If the fix is more extensive or spans multiple hunks, Atlas employs `apply_patch` to ensure a robust and atomic change. The core principle is always to fix the underlying code logic, not merely adjust the test assertion. After applying the fix, Atlas re-runs the single failing test to confirm the immediate resolution, followed by the full test suite to ensure no regressions were introduced. A crucial step in maintaining code quality is Atlas's ability to run `bun fmt` over the generated diff before the changes are approved. This ensures that all modifications adhere to the project's established formatting guidelines, making the code review process smoother and preventing style inconsistencies.

Atlas's Safety and Review Mechanisms for Bun Projects

Atlas incorporates robust safety and review mechanisms, ensuring that every action taken in a Bun project is transparent and approved. Every Atlas tool call is permission-gated, and all proposed code edits are presented as a unified diff for user approval before writing to disk, offering 100% control.

Safety and developer control are paramount when using Atlas in a Bun project. Before any tool call, whether it's `bash` to run `bun test`, `lsp` to navigate code, or `edit` to propose a fix, Atlas consults permission-gated rules (allow, ask, deny). This means you are always in control of what Atlas can execute. When Atlas drafts a plan, it does so in a read-only plan agent, asking for approval before switching to a build agent to execute changes. Crucially, every file edit Atlas proposes is presented as a unified diff, allowing you to review the exact changes before they are written to disk. Atlas also integrates with Git, reading branches, status, and diffs, and can stage and create commits on your behalf, always with your explicit approval. This comprehensive review process ensures that all changes to your Bun codebase are intentional and thoroughly vetted.

Step by step

01Run the failing Bun test in isolation: Instruct Atlas to execute `bun test --filter "your failing test name"` using its `bash` tool to narrow down the problem.
02Analyze the Bun test and exercised module: Use Atlas's `read` tool to examine the test file and the module it targets. Then, employ the `lsp` tool's `goToDefinition` and `findReferences` operations to trace the call graph within your Bun project.
03Form a hypothesis and verify: Ask Atlas to propose a hypothesis for the failure. Check it by adding temporary logging with Atlas's `edit` tool or re-running `bun test` with a `--verbose` flag via `bash`.
04Fix the production code: Direct Atlas to fix the underlying production code using its `edit` tool for small changes or `apply_patch` for more extensive modifications, ensuring the fix addresses the root cause, not just the test assertion.
05Re-run tests and clean up: Have Atlas re-run the single failing test with `bun test`, then the full test suite. Finally, instruct Atlas to remove any temporary logging added during debugging.
06Format and commit changes: Before approving the commit, ask Atlas to run `bun fmt` over the diff to ensure code style consistency, then review the unified diff and approve Atlas to stage and commit the changes.

Frequently asked questions

How does Atlas run `bun test`?: Atlas uses its `bash` tool to execute `bun test` commands directly, just as you would in your terminal. This allows it to leverage all native `bun test` flags, such as `--filter` for isolating specific tests or `--verbose` for detailed output, providing a familiar debugging experience.
Can Atlas debug a failing test in a large Bun project?: Yes, Atlas is designed for large projects. It indexes code by AST declarations using Tree-sitter, not blind line windows, and uses hybrid semantic and keyword retrieval, making it efficient for navigating and understanding extensive Bun codebases, even in 2026.
What if Atlas suggests fixing the test assertion instead of the code?: Atlas is specifically instructed to find why a test fails and fix the *code*, not the assertion. Its workflow focuses on walking the call graph with the `lsp` tool and identifying the root cause in the production logic, ensuring a practical option.
How does Atlas ensure code quality after a fix in Bun?: After proposing a fix, Atlas can run `bun fmt` over the generated diff before you approve the commit. This ensures that any changes adhere to your project's formatting standards, maintaining code consistency and simplifying subsequent code reviews.
Is my Bun code safe when Atlas is making changes?: Yes, Atlas prioritizes safety. Every tool call is permission-gated against allow, ask, and deny rules, and all proposed code edits are presented as a unified diff for your explicit approval before any changes are written to disk. Atlas also snapshots file changes as git patches for easy rollback.
Can Atlas use my local Ollama embeddings for Bun code?: Yes, Atlas can build its code index with local Ollama embeddings, ensuring that your Bun project's code remains off third-party servers and is processed securely within your local environment. This provides enhanced privacy and control over your codebase.
How does Atlas handle complex Bun API usage during debugging?: Atlas is designed to read and understand Bun-native APIs like `Bun.serve`, `Bun.file`, and `bun:sqlite`. This allows it to accurately interpret and debug code that leverages Bun's specific features and idioms, providing relevant insights for complex Bun applications.

Try Atlas in your terminal

The terminal-native AI coding agent. Free core, single binary.

Install Atlas

Related guides

Debug a Single Failing Test with Atlas in 2026

How to debug one failing test with Atlas in 2026: run it in isolation with bash, walk the call graph with the lsp tool, and fix the code, not the assertion.

Atlas for Bun: Terminal-Native AI Coding in 2026

Atlas is a terminal-native AI coding agent for Bun. Swap Node compatibility shims for Bun.serve and bun:sqlite, iterate with bun test, and format with bun fmt in 2026.

Locate where a behavior is implemented in Bun with Atlas in 2026

Pinpoint the exact file and symbol responsible for any behavior in your Bun codebase using Atlas. Leverage semantic search, `grep`, and LSP tools for precise results and a streamlined workflow.

Diagnose a Hanging or Long-Running Command in Bun with Atlas in 2026

Pinpoint why your Bun scripts or builds are stuck in 2026. Atlas helps Bun developers diagnose if a command is genuinely slow or silently blocked on input, providing clear steps to get unstuck.

Rename a symbol across the repo in Bun with Atlas in 2026

Rename functions, classes, or constants across your Bun project with Atlas in 2026. Atlas uses LSP, grep, and `bun test` for precise, verified refactoring.

Refactor a Legacy Module in Bun with Atlas in 2026

Refactor legacy Bun modules safely with Atlas, the terminal-native AI agent. Leverage `bun test` and `bun fmt` for verified changes, ensuring no breaking callers in your 2026 Bun projects. Atlas maps APIs, pins

Self-review your working diff before committing in Bun with Atlas in 2026

Catch your own mistakes in uncommitted Bun diffs before they reach review or CI. Atlas helps Bun developers in 2026 self-review code, run `bun test`, and `bun fmt`.

Write unit tests for untested code in Bun with Atlas in 2026

Learn how Atlas helps Bun developers in 2026 add real unit tests to untested modules, matching existing repo conventions using `bun test`, `bun install`, and `bun fmt`.

Browse this resource hub