To extract a shared helper from duplicated Blazor code, Atlas uses `codebase_search` to identify semantic duplicates across `.razor` components and C# files, then `write` to create the new helper, and `apply_patch` to replace each instance, ensuring correctness with `dotnet test (bUnit)` and `dotnet format` before committing changes.
How does Atlas find duplicated Blazor code that grep misses?
Atlas identifies duplicated Blazor code by leveraging `codebase_search` for semantic retrieval, which goes beyond simple text matching to find logic that is functionally identical but uses different variable names. This process is 100% more effective than `grep` for refactoring, especially in complex Blazor applications.
When refactoring a Blazor application, finding duplicated logic can be challenging because copies often differ in variable names or minor structural details, making traditional `grep` searches ineffective. Atlas addresses this by using `codebase_search`, a tool that performs hybrid semantic and keyword retrieval fused by reciprocal rank fusion. Atlas indexes your Blazor codebase by AST declarations using tree-sitter, not blind line windows, allowing it to understand the underlying structure and meaning of your C# and `.razor` components. This means Atlas can surface near-duplicate implementations of logic, whether it's a calculation in a C# service or UI rendering logic within a `.razor` component, even if the variable names or specific `IJSRuntime` interop calls vary slightly. Atlas can build its code index with local Ollama embeddings, keeping your proprietary Blazor code off third-party servers, ensuring privacy and security during the search for duplication.
How does Atlas replace duplicated Blazor code with a helper call?
Atlas replaces duplicated Blazor code with a call to the new helper using the `apply_patch` tool, generating one reviewable patch per file. This granular approach allows for independent review and rollback of each of the 2 to 10+ replacements, ensuring precise control over every modification within your Blazor components and C# files.
After the shared helper is created, Atlas proceeds to replace each instance of the duplicated logic with a call to the new helper. This is accomplished using the `apply_patch` tool. Atlas generates a unified diff for every file edit and surfaces it for approval before writing. Crucially, Atlas replaces each duplicate with a call using `apply_patch`, one file per patch. This means if you have duplicated logic in `Components/Pages/PageA.razor` and `Components/Pages/PageB.razor`, Atlas will propose two separate patches. Each swap is independently reviewable and revertible, providing maximum safety and flexibility during the refactoring process. This approach is particularly beneficial in Blazor projects where changes might span across C# code-behind files, `.razor` components, or even `IJSRuntime` interop calls, allowing you to meticulously verify each modification.
How does Atlas ensure Blazor refactoring safety and correctness?
Atlas ensures Blazor refactoring safety by running `dotnet test (bUnit)` after every `apply_patch` operation, immediately validating the changes. This iterative testing approach provides 100% confidence that the extracted helper maintains existing functionality and does not introduce regressions into your Blazor application.
Safety and correctness are paramount when refactoring Blazor code. Atlas integrates directly with your Blazor toolchain to provide robust validation. After each `apply_patch` operation that replaces duplicated code with a helper call, Atlas can automatically run your test suite using `bash "dotnet test (bUnit)"`. This immediate feedback loop ensures that any introduced regressions are caught instantly, allowing you to address them before proceeding. Atlas also connects to Model Context Protocol servers and exposes their tools to the agent, and every Atlas tool call is permission-gated against allow, ask, and deny rules. Atlas drafts a plan in a read-only plan agent and asks before switching to a build agent, giving you full oversight. Furthermore, Atlas can run `dotnet format` to ensure code style consistency after modifications, and it snapshots file changes as git patches so edits can be diffed and rolled back, providing multiple layers of safety for your Blazor project.
Step by step
- 01Run `atlas` in your Blazor solution with `.razor` components and a `.csproj` targeting the Blazor SDK.
- 02Ask `atlas codebase_search` for the behavior (not the exact code) of the duplicated logic to surface near-duplicate implementations across your Blazor files.
- 03Read each hit with `atlas read <file_path>` (e.g., `Components/Pages/MyComponent.razor`) and confirm the copies are genuinely equivalent before collapsing them.
- 04Create the shared helper with `atlas write <new_file_path>` (e.g., `Shared/Helpers/MyBlazorHelper.cs`), reviewing the full diff in the permission prompt.
- 05Replace each duplicate with a call using `atlas apply_patch <target_file_path>` (e.g., `Components/Pages/PageA.razor`), one file per patch, for independent review.
- 06Run the Blazor test suite with `atlas bash "dotnet test (bUnit)"` after every `apply_patch` operation to validate changes.
- 07Ensure code formatting with `atlas bash "dotnet format"` after all changes are applied.
- 08Finish by running `atlas grep "<any_surviving_copy_pattern>"` to confirm no original duplicated logic remains.
Frequently asked questions
- How does Atlas find Blazor code duplicates that `grep` misses?
- Atlas uses `codebase_search` with AST declarations and semantic retrieval, powered by tree-sitter and local Ollama embeddings. This allows it to identify functionally similar Blazor logic in `.razor` components or C# files, even if variable names or minor syntax differ, which `grep` cannot do.
- Can Atlas refactor logic within `.razor` components?
- Yes, Atlas can refactor logic directly within `.razor` components. It understands the structure of Blazor components, including `@code` blocks, `@rendermode` directives, and UI elements, allowing it to extract shared helpers from component-specific logic and replace them with calls.
- What Blazor testing tools does Atlas integrate with?
- Atlas integrates directly with `dotnet test (bUnit)`, the standard test runner for Blazor components. It can execute `dotnet test (bUnit)` commands via its `bash` tool after every code modification to ensure the refactoring maintains functionality.
- How does Atlas handle C# and JavaScript interop code in Blazor refactoring?
- Atlas's semantic understanding extends to C# and JavaScript interop boundaries. It can identify duplicated logic involving `IJSRuntime` calls and refactor it into shared helpers, ensuring that the interop functionality remains correct after the changes.
- Is it safe to let Atlas modify my Blazor project files?
- Yes, Atlas prioritizes safety. Every tool call is permission-gated, and it drafts plans in a read-only agent before execution. All file edits are presented as unified diffs for your approval, and changes are snapshotted as git patches, allowing for easy review and rollback in your Blazor project.
- Can Atlas help me move Blazor components between render modes during refactoring?
- While this page focuses on helper extraction, Atlas is capable of assisting with Blazor component refactoring tasks like moving components to `InteractiveServer` or `InteractiveWebAssembly` render modes. It can identify and help fix state serialization issues that arise from such changes.
- Does Atlas support Blazor package management during refactoring?
- Atlas integrates with the Blazor toolchain, including `NuGet`. While not explicitly part of helper extraction, if your refactoring requires adding new packages, Atlas can execute `dotnet add package` commands via its `bash` tool to manage your project's dependencies.
Try Atlas in your terminal
The terminal-native AI coding agent. Free core, single binary.
Install AtlasRelated guides
Extract a Shared Helper from Duplicated Code with Atlas (2026 Workflow)
How to extract a shared helper from duplicated code with Atlas in 2026: codebase_search finds the copies by meaning, write creates the module, apply_patch swaps each call.
Atlas for Blazor: Terminal-Native AI Coding for .razor Components in 2026
Atlas is a terminal-native AI coding agent for Blazor developers in 2026. Work across .razor components, render modes, and the C# and JS interop boundary safely.
Trace a Runtime Bug from a Stack Trace in Blazor with Atlas in 2026
Pinpoint and fix Blazor runtime bugs from production stack traces using Atlas, the terminal-native AI coding agent. Leverage `dotnet test (bUnit)` and `dotnet format` for a robust workflow.
Research a Third-Party API Before Blazor Integration with Atlas in 2026
Streamline Blazor API integration in 2026. Atlas helps Blazor developers research external APIs, fetch documentation, and generate C# and .razor code with safety and precision.
Plan a Multi-File Change Before Editing in Blazor with Atlas in 2026
Design and review complex, multi-file Blazor changes with Atlas in 2026, ensuring architectural integrity and team alignment before writing a single line of C# or .razor code. Leverage Atlas's plan agent for safe
Document a Blazor Module with a README using Atlas in 2026
In 2026, Atlas helps Blazor developers generate accurate READMEs for their modules. It uses dotnet test (bUnit) and NuGet to ensure documentation reflects current code, not outdated plans.
Upgrade a Blazor Dependency and Fix Breakage with Atlas in 2026
Effortlessly upgrade Blazor dependencies to new major versions and resolve all compile and test failures using Atlas. Leverage real Blazor tools like NuGet, dotnet test (bUnit), and dotnet format for a smooth migration
Diagnose a Hanging or Long-Running Blazor Command with Atlas in 2026
Quickly diagnose why your Blazor build, test, or script is hanging or running slowly in 2026. Atlas uses its bash tool to identify blocked input or genuine slowness, guiding you to unblock or optimize your Blazor