How does Atlas handle SolidJS reactivity graphs?

Atlas indexes your SolidJS project by AST declarations using tree-sitter, specifically understanding `createSignal`, `createMemo`, and `createEffect` graphs. This allows it to semantically search and trace reactivity patterns, helping you locate where a behavior is implemented even if your query doesn't match exact code.

Can Atlas help fix common SolidJS bugs like destructured props?

Yes, Atlas is designed to identify and fix common SolidJS bugs, such as reactivity issues caused by destructured props. It can draft a plan to correct the code and will present a unified diff for your review and approval before applying any changes to your `.tsx` files.

What SolidJS tools does Atlas integrate with?

Atlas integrates direct with your SolidJS toolchain. It recognizes `vite.config.ts` using `vite-plugin-solid`, works with `pnpm` for package management, and can add tests with `@solidjs/testing-library` and run `vitest`. It also formats touched `.tsx` files using `prettier` after edits.

Is my SolidJS code sent to third-party servers when using Atlas?

No, Atlas can build its code index with local Ollama embeddings, ensuring your SolidJS codebase remains entirely on your machine. This keeps your proprietary code off third-party servers, maintaining privacy and security for your projects.

How does Atlas ensure I approve all SolidJS code changes?

Atlas employs a robust safety mechanism. It first drafts a plan in a read-only agent and asks for permission before proceeding. Every file edit generates a unified diff for your approval, and changes are snapshotted as git patches, allowing for easy review and rollback of any SolidJS code modifications.

Can Atlas help me find all references to a SolidJS signal?

Absolutely. Once you've identified a specific SolidJS signal or component, you can use the `atlas lsp findReferences MySignalName` command. This leverages the Language Server Protocol to show you every callsite and usage of that signal within your SolidJS project, making it easy to understand its impact.

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

To locate where a behavior is implemented in SolidJS, Atlas combines semantic codebase search, precise `grep` functionality, and the `lsp` tool to identify the exact file and symbol. This approach helps SolidJS developers in 2026 quickly navigate complex reactivity graphs and component logic, integrating direct with `pnpm` for dependency management and `vitest (@solidjs/testing-library)` for testing.

How does Atlas find SolidJS behavior implementations?

Atlas locates SolidJS behavior implementations by attacking the problem from three angles simultaneously, ensuring comprehensive coverage. In 2026, it leverages hybrid semantic and keyword retrieval, `grep` for exact text, and the `lsp` tool for symbol graph analysis, providing a practical option for even the most intricate `createSignal` dependencies.

Atlas provides a powerful suite of tools to pinpoint where a behavior is implemented within a SolidJS codebase. First, `codebase_search` uses hybrid semantic and keyword retrieval, indexing your code by AST declarations with tree-sitter. This means Atlas understands the structure of your SolidJS project, including the `createSignal`, `createMemo`, and `createEffect` reactivity graphs, even if your search query doesn't contain exact keywords from the source. It can build this index using local Ollama embeddings, keeping your SolidJS code off third-party servers. Second, `grep` offers precise keyword matching, powered by `ripgrep`. This tool accepts real regex patterns along with include and path filters, allowing you to confirm semantic search results or find exact text occurrences within your `.tsx` files. Finally, the `lsp` tool taps into the Language Server Protocol, providing symbol graph capabilities. This allows Atlas to find references to SolidJS components, signals, or functions, and jump to their declarations by name, offering a deep understanding of the code's structure and interconnections. These three complementary approaches ensure that SolidJS developers can efficiently locate any behavior, regardless of whether they know the exact code name or only its functional description.

What Atlas commands locate SolidJS code?

SolidJS developers use specific Atlas commands to pinpoint code locations, starting with `codebase_search` to describe the behavior. This initial step, crucial in 2026, quickly narrows down potential files, often identifying the correct `.tsx` component or utility responsible for a given action within 10 seconds.

To locate SolidJS code, you'll interact with Atlas using a series of targeted commands. Begin by describing the behavior you're investigating to the semantic search tool: `atlas codebase_search "describe the user interaction or reactivity pattern"`. This will return candidate declarations from your SolidJS project, often pointing to relevant `.tsx` files or utility modules. Next, to confirm or refine these candidates, use `atlas grep "specific_keyword_or_regex" --include "*.tsx"`. This command is invaluable for finding exact text matches within your SolidJS components or stores. Once you have a promising file path, open it for inspection with `atlas read src/components/MySolidComponent.tsx`. If you make a wrong guess, Atlas will loudly fail with 'File not found' and provide a 'Did you mean' list, preventing wasted time. For deeper analysis within a file, the `lsp` tool is essential. Use `atlas lsp findReferences MySignalName` to see every callsite of a specific SolidJS signal or component. Alternatively, `atlas lsp workspaceSymbol MyFunctionName` allows you to jump directly to the declaration of any symbol by name, streamlining navigation through your SolidJS codebase. After identifying the implementation, Atlas can summarize the call path back to you with concrete file and line references.

How does Atlas ensure safe SolidJS code changes?

Atlas ensures safe SolidJS code changes through a multi-stage review process, starting with a read-only plan agent. Every proposed modification, whether fixing a destructured prop or adding a new `createSignal`, generates a unified diff for user approval, preventing unintended alterations to your `.tsx` files in 2026.

Atlas prioritizes safety and user control throughout the code modification process for SolidJS projects. Before any changes are made, Atlas drafts a plan in a read-only plan agent, which it presents to you for review. This allows you to understand the proposed actions without any risk to your codebase. Every Atlas tool call is permission-gated, operating under 'allow', 'ask', or 'deny' rules that you configure, ensuring explicit consent for operations like running `vitest (@solidjs/testing-library)` or modifying files. When Atlas proposes an edit, such as fixing a common SolidJS reactivity bug related to destructured props, it computes a unified diff for every file change. This diff is surfaced for your approval, giving you a clear, line-by-line view of what will be altered in your `.tsx` files. Atlas also connects to Model Context Protocol servers, exposing their tools to the agent, and can snapshot file changes as git patches. This means edits can be easily diffed against previous states and rolled back if necessary. After changes are approved, Atlas can even run `prettier` on the touched `.tsx` files to maintain consistent formatting, all under your explicit permission.

Step by step

011: Initiate your search by describing the SolidJS behavior to Atlas using `atlas codebase_search "describe the UI behavior or reactivity pattern"`. Atlas indexes your `createSignal`, `createMemo`, and `createEffect` graphs, providing relevant `.tsx` component or utility candidates.
022: Refine the results by confirming potential files with `atlas grep "specific_keyword_or_regex" --include "*.tsx"`. This leverages `ripgrep` to find exact text matches within your SolidJS source files, ensuring precision.
033: Examine a promising candidate file, such as `src/components/UserProfile.tsx`, using `atlas read src/components/UserProfile.tsx`. If the path is incorrect, Atlas will provide a 'Did you mean' list, guiding you to the right SolidJS component.
044: Once inside a relevant `.tsx` file, use `atlas lsp findReferences MySignal` or `atlas lsp findReferences MyComponent` to see every callsite of a specific SolidJS signal or component. Alternatively, `atlas lsp workspaceSymbol MyFunction` jumps directly to a declaration.
055: Conclude by asking Atlas to summarize the call path and implementation details, providing concrete file and line references for the SolidJS behavior you investigated.

Frequently asked questions

How does Atlas handle SolidJS reactivity graphs?: Atlas indexes your SolidJS project by AST declarations using tree-sitter, specifically understanding `createSignal`, `createMemo`, and `createEffect` graphs. This allows it to semantically search and trace reactivity patterns, helping you locate where a behavior is implemented even if your query doesn't match exact code.
Can Atlas help fix common SolidJS bugs like destructured props?: Yes, Atlas is designed to identify and fix common SolidJS bugs, such as reactivity issues caused by destructured props. It can draft a plan to correct the code and will present a unified diff for your review and approval before applying any changes to your `.tsx` files.
What SolidJS tools does Atlas integrate with?: Atlas integrates direct with your SolidJS toolchain. It recognizes `vite.config.ts` using `vite-plugin-solid`, works with `pnpm` for package management, and can add tests with `@solidjs/testing-library` and run `vitest`. It also formats touched `.tsx` files using `prettier` after edits.
Is my SolidJS code sent to third-party servers when using Atlas?: No, Atlas can build its code index with local Ollama embeddings, ensuring your SolidJS codebase remains entirely on your machine. This keeps your proprietary code off third-party servers, maintaining privacy and security for your projects.
How does Atlas ensure I approve all SolidJS code changes?: Atlas employs a robust safety mechanism. It first drafts a plan in a read-only agent and asks for permission before proceeding. Every file edit generates a unified diff for your approval, and changes are snapshotted as git patches, allowing for easy review and rollback of any SolidJS code modifications.
Can Atlas help me find all references to a SolidJS signal?: Absolutely. Once you've identified a specific SolidJS signal or component, you can use the `atlas lsp findReferences MySignalName` command. This leverages the Language Server Protocol to show you every callsite and usage of that signal within your SolidJS project, making it easy to understand its impact.

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 SolidJS: A Terminal-Native AI Coding Agent Built on Solid, for Solid, in 2026

Atlas is a terminal-native AI coding agent for SolidJS in 2026. It reads your createSignal and createMemo graph, fixes destructured props that break reactivity, and runs vitest.

Upgrade a Dependency and Fix Breakage in SolidJS with Atlas in 2026

SolidJS developers in 2026 can use Atlas to efficiently upgrade major dependencies, automatically fixing compile and test failures. Atlas integrates with pnpm, vitest, and prettier to streamline your workflow.

Diagnose a hanging or long-running command in SolidJS with Atlas in 2026

Pinpoint why your SolidJS builds or scripts are stuck or slow in 2026. Atlas, the terminal-native AI agent, uses its bash tool to diagnose interactive input blocks or genuine performance bottlenecks in your pnpm

Refactor a Legacy SolidJS Module with Atlas in 2026

Streamline your SolidJS codebase in 2026 by refactoring legacy modules with Atlas. Maintain behavior, prevent breaking changes, and leverage your existing pnpm, vitest, and prettier toolchain.

Run Atlas Headless in CI for SolidJS Projects in 2026

Automate Atlas in your SolidJS CI pipeline for machine-readable output. Leverage pnpm, vitest, and prettier to integrate AI-driven code changes and testing direct in 2026.

Extract a Shared Helper from Duplicated Code in SolidJS with Atlas in 2026

Refactor your SolidJS codebase in 2026 by extracting duplicated logic into a shared helper using Atlas. Leverage pnpm, vitest (@solidjs/testing-library), and prettier for a streamlined workflow.

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

Catch your own mistakes in SolidJS before they reach review or CI. Atlas helps SolidJS developers in 2026 self-review uncommitted diffs, run vitest, prettier, and manage changes.

Browse this resource hub