Can Atlas find code in my Bun project if I only know what it does?

Yes, Atlas excels at this. Its `codebase_search` tool uses hybrid semantic and keyword retrieval, allowing you to describe a behavior in natural language. It will return relevant declarations from your Bun project, even if your query doesn't match exact code terms, understanding concepts like "serve HTTP requests" for `Bun.serve`.

How does Atlas handle Bun's specific file types and configurations?

Atlas is designed to integrate direct with Bun projects. It automatically recognizes `bun.lock` and `package.json` files. It indexes Bun-native APIs such as `Bun.serve`, `Bun.file`, and `bun:sqlite`, and understands scripts defined in `package.json`, ensuring its tools are contextually aware of your Bun environment.

What if Atlas suggests a change to my Bun code? How do I review it?

Atlas prioritizes safety. It drafts a plan in a read-only agent for your approval first. If a change is proposed, it computes a unified diff for every file edit and surfaces it for your review. Atlas can also run `bun test` to confirm behavior and `bun fmt` over the diff before you approve the commit, ensuring code quality in your Bun project.

Can Atlas help me understand the call stack for a Bun function?

Absolutely. Once you've identified a specific symbol in your Bun project, Atlas's `lsp` tool can help. You can use `lsp findReferences ` to see every location where that function is called, effectively mapping out its call sites and helping you understand its execution flow.

Does Atlas keep my Bun code private when indexing?

Yes, Atlas offers options for privacy. It can build its code index using local Ollama embeddings, which means your Bun project's source code never leaves your machine and is not sent to third-party servers for processing. This ensures your proprietary code remains secure.

How does Atlas ensure code style consistency in my Bun project?

Atlas integrates with your existing Bun toolchain. When proposing code changes, it can run `bun fmt` over the generated diff before presenting it for your approval. This ensures that any modifications Atlas makes adhere to your project's established formatting rules, maintaining consistency across your Bun codebase.

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

In 2026, Bun developers can efficiently locate where a behavior is implemented using Atlas, the terminal-native AI coding agent, even when only knowing what the software does. Atlas integrates directly with your Bun project, understanding `bun test` for verification, `bun install` for dependencies, and `bun fmt` for code style, providing a direct workflow to identify the precise file and symbol responsible for any observed action.

How does Atlas find specific behavior implementations in Bun?

Atlas identifies where a behavior is implemented in Bun by attacking the problem from three complementary angles simultaneously, ensuring comprehensive retrieval. This 2026 workflow combines semantic understanding, exact text matching, and symbol graph navigation to pinpoint the precise code responsible.

Atlas employs a robust strategy to locate behavior within your Bun codebase. It begins with `codebase_search`, which uses hybrid semantic and keyword retrieval fused by reciprocal rank fusion. This means you can describe what the Bun application does, like "how does the HTTP server handle requests," and Atlas will return candidate declarations even if your exact words aren't in the source code, understanding `Bun.serve` or related logic. Next, `grep` confirms these findings with exact text matching, allowing for real regex patterns and specific include/path filters, crucial for narrowing down results in a large Bun project. Finally, the `lsp` tool leverages the language server protocol to work through the symbol graph, providing insights into declarations and references, ensuring the identified code is the definitive source of the behavior.

How to semantically search for Bun-native APIs with Atlas?

Atlas's `codebase_search` tool excels at understanding the intent behind your queries, making it ideal for locating implementations of Bun-native APIs like `Bun.serve` or `Bun.file`. This semantic capability allows developers in 2026 to describe functionality in natural language, even without knowing the exact function names.

When you need to find how a specific behavior is implemented in Bun, but only know its function, Atlas's `codebase_search` is your first step. You can describe the behavior, such as "how does the application serve static files" or "where is the SQLite database connection handled." Atlas, having indexed your code by AST declarations using tree-sitter, understands the structure and meaning of your Bun project. It can identify relevant code snippets involving `Bun.file` for file operations or `bun:sqlite` for database interactions, even if your query doesn't contain those exact keywords. This semantic understanding is particularly powerful for exploring unfamiliar Bun codebases or when a behavior is implemented across multiple symbols. Atlas can also build its code index with local Ollama embeddings, keeping your sensitive Bun code off third-party servers.

How do I confirm Bun code paths using Atlas's `grep`?

After an initial semantic search, Atlas's `grep` tool provides a crucial second layer of verification, allowing Bun developers to confirm candidate code paths with precise text matching. This tool, powered by `ripgrep`, supports real regex patterns and specific file filters, often narrowing results down to just 1 or 2 files in your Bun project.

Once `codebase_search` provides potential locations for a Bun behavior, the `grep` tool allows for precise confirmation. You can instruct Atlas to `grep` for specific strings, variable names, or function calls that you suspect are involved. For instance, if you're investigating a network issue, you might `grep` for "fetch" or "socket" within files identified by the semantic search. Atlas's `grep` supports advanced regex, allowing you to refine your search with patterns like `^export const (.*) = Bun\.serve` to find specific server declarations. You can also apply include and path filters, such as `grep --include='*.ts' src/server/` to narrow the search to TypeScript files within a specific directory, ensuring you're only looking at relevant Bun source code. This combination of semantic and exact search is why Atlas ships both tools.

How to navigate Bun symbol graphs with Atlas's LSP tool?

Atlas's `lsp` tool provides deep insights into the symbol graph of your Bun project, enabling developers to trace function calls and jump to declarations with precision. This capability is essential for understanding the full context of a behavior, offering operations like `findReferences` and `workspaceSymbol` to explore your Bun code, often revealing 10s or 100s of callsites.

After identifying a promising file with `read`, the `lsp` tool becomes invaluable for understanding the full scope of a Bun behavior. If you've found a function that seems to be the core of the behavior, you can use `lsp findReferences <symbol_name>` to see every callsite across your entire Bun project. This helps you understand how the behavior is triggered and what other parts of the application interact with it. Conversely, if you know a symbol's name but not its location, `lsp workspaceSymbol <symbol_name>` allows you to jump directly to its declaration, providing instant navigation. This is particularly useful in large Bun codebases where a single behavior might involve multiple interconnected modules or files, such as `utils/auth.ts` calling `db/user.ts` which uses `bun:sqlite`. Atlas connects to Model Context Protocol servers, exposing their powerful tools to the agent for rich code understanding.

How does Atlas ensure safe review and commit of Bun code changes?

Atlas prioritizes safety and transparency when proposing changes to your Bun project, ensuring every modification is thoroughly reviewed before being applied. It drafts a plan in a read-only agent, computes unified diffs, and can even run `bun fmt` over proposed edits, giving you full control over the 2026 development cycle.

Atlas integrates direct with your Bun development workflow, providing multiple layers of review and safety. Before making any modifications, Atlas drafts a plan in a read-only plan agent and asks for your approval before switching to a build agent. This ensures you understand the proposed approach. When Atlas suggests a code change, such as replacing a Node compatibility shim with a native Bun API, it computes a unified diff for every file edit and surfaces it for your approval. This allows you to inspect every line change. Furthermore, Atlas can run `bun test` behind a permission prompt to confirm behavior, and `bun fmt` over the diff before you approve the commit, ensuring your Bun project's code style is maintained. Atlas also reads git branches, status, and diffs, and can stage and create commits on your behalf, or snapshot file changes as git patches for easy rollback.

How do I set up Atlas for my Bun project?

Setting up Atlas for your Bun project is straightforward, requiring minimal configuration to unlock its full potential for code understanding and modification. Simply run Atlas in a project containing a `bun.lock` and a `package.json` file, and it will automatically begin indexing your Bun-native APIs and scripts, typically completing the initial scan in under 30 seconds for most projects.

To leverage Atlas for locating behavior in your Bun project, start by running `atlas` in your project's root directory. Atlas will automatically detect your `bun.lock` and `package.json` files, indicating a Bun environment. It then proceeds to read and index your Bun-native APIs, such as `Bun.serve`, `Bun.file`, and `bun:sqlite`, along with any scripts defined in your `package.json`. This initial indexing process is crucial for Atlas's `codebase_search` and `lsp` tools to function effectively. For enhanced privacy and control, Atlas can build its code index using local Ollama embeddings, ensuring your proprietary Bun code never leaves your machine. Atlas also ships a TUI theme system with a charcoal-and-blue default theme, offering a customizable terminal experience for your Bun development.

Step by step

01Describe the behavior to Atlas: Start by asking Atlas to `codebase_search` for the behavior you observe, using natural language like "how does the HTTP server handle requests in Bun?"
02Review semantic candidates: Atlas will return candidate declarations from your Bun project, even if your exact words aren't present. Review these for relevance.
03Confirm with `grep`: Use Atlas's `grep` tool with a real regex and path filters (e.g., `grep --include='*.ts' 'Bun.serve'`) to confirm the exact text and file paths of the candidate code.
04Open the best candidate: Use `read <file_path>` to open the most promising Bun source file. Atlas will loudly fail if the path is wrong, offering "Did you mean" suggestions.
05Explore with `lsp`: If you've found a symbol, use `lsp findReferences <symbol_name>` to see all callsites, or `lsp workspaceSymbol <symbol_name>` to jump to its declaration within your Bun project.
06Summarize the call path: Ask Atlas to summarize the call path back to you, including concrete Bun file and line references, to fully understand the behavior's implementation.
07Approve or refine: Review Atlas's findings. If a change is proposed, Atlas will show a unified diff and can run `bun test` and `bun fmt` before you approve the commit.

Frequently asked questions

Can Atlas find code in my Bun project if I only know what it does?: Yes, Atlas excels at this. Its `codebase_search` tool uses hybrid semantic and keyword retrieval, allowing you to describe a behavior in natural language. It will return relevant declarations from your Bun project, even if your query doesn't match exact code terms, understanding concepts like "serve HTTP requests" for `Bun.serve`.
How does Atlas handle Bun's specific file types and configurations?: Atlas is designed to integrate direct with Bun projects. It automatically recognizes `bun.lock` and `package.json` files. It indexes Bun-native APIs such as `Bun.serve`, `Bun.file`, and `bun:sqlite`, and understands scripts defined in `package.json`, ensuring its tools are contextually aware of your Bun environment.
What if Atlas suggests a change to my Bun code? How do I review it?: Atlas prioritizes safety. It drafts a plan in a read-only agent for your approval first. If a change is proposed, it computes a unified diff for every file edit and surfaces it for your review. Atlas can also run `bun test` to confirm behavior and `bun fmt` over the diff before you approve the commit, ensuring code quality in your Bun project.
Can Atlas help me understand the call stack for a Bun function?: Absolutely. Once you've identified a specific symbol in your Bun project, Atlas's `lsp` tool can help. You can use `lsp findReferences <symbol_name>` to see every location where that function is called, effectively mapping out its call sites and helping you understand its execution flow.
Does Atlas keep my Bun code private when indexing?: Yes, Atlas offers options for privacy. It can build its code index using local Ollama embeddings, which means your Bun project's source code never leaves your machine and is not sent to third-party servers for processing. This ensures your proprietary code remains secure.
How does Atlas ensure code style consistency in my Bun project?: Atlas integrates with your existing Bun toolchain. When proposing code changes, it can run `bun fmt` over the generated diff before presenting it for your approval. This ensures that any modifications Atlas makes adhere to your project's established formatting rules, maintaining consistency across your Bun codebase.

Try Atlas in your terminal

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

Install Atlas

Related guides

Locate Where a Behavior Is Implemented with Atlas in 2026

How to locate where a behavior is implemented with Atlas in 2026: codebase_search for meaning, grep for exact text, and the lsp tool for the symbol graph.

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.

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.

Audit a Bun Repository with Parallel Subagents in 2026

Sweep your Bun repository for problems without context window limits using Atlas's parallel subagents. Leverage bun test, bun install, and bun fmt for efficient, safe audits.

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

Migrate a deprecated API across every callsite in Bun with Atlas in 2026

Effortlessly migrate deprecated APIs across your Bun codebase in 2026 using Atlas. Ensure every callsite is updated with precision, leveraging `bun test` and `bun fmt` for verified changes.

Onboard to an Unfamiliar Bun Codebase with Atlas in 2026

Quickly build a mental model of any Bun codebase using Atlas, the terminal-native AI coding agent. Understand `bun test`, `bun install`, and `bun fmt` workflows.

Run the Bun Test Suite and Triage Failures with Atlas in 2026

Streamline Bun test suite triage in 2026 with Atlas, the terminal-native AI agent. Quickly turn red `bun test` output into a prioritized list of distinct root causes, ensuring efficient bug resolution.

Browse this resource hub