To extract a shared helper from duplicated Scala code, Atlas leverages its semantic search capabilities to identify near-duplicate logic across your codebase, even when variable names differ. It then guides you through creating a new Scala module, replacing each instance with a call to the new helper, and validating changes with `ScalaTest via sbt test` and `scalafmt` before committing in 2026.
How to find duplicated Scala logic across files with Atlas?
Atlas identifies duplicated Scala logic across multiple files by employing hybrid semantic and keyword retrieval, fused by reciprocal rank fusion, a technique far more effective than simple text-based `grep` in 2026. This allows it to surface near-duplicate implementations that share behavior but might use different variable names or minor structural variations.
When you need to find duplicated Scala code, Atlas's `codebase_search` tool is your primary ally. Instead of searching for exact text, which often misses semantically identical but syntactically different code, Atlas indexes your Scala project by AST declarations using tree-sitter. This deep understanding of your code's structure allows `codebase_search` to identify the *behavior* you're looking for. For instance, if you suspect a specific calculation or data transformation is duplicated, you can ask Atlas to find that behavior. Atlas can build its code index with local Ollama embeddings, ensuring your proprietary Scala code remains off third-party servers. After `codebase_search` returns potential matches, you'll `read` each hit to confirm the copies are genuinely equivalent and suitable for collapsing into a single, tested helper.
How to create a new Scala helper module with Atlas?
Creating a new shared Scala helper module is straightforward with Atlas's `write` tool, which drafts the new file and its contents, showing a full diff for approval before creation. This ensures you have complete control over the new `src/main/scala` file, typically within 1-2 minutes of confirming the duplicated logic.
Once you've identified the duplicated Scala logic and confirmed its equivalence, the next step is to create the shared helper. Atlas's `write` tool facilitates this by allowing you to specify the new file path, such as `src/main/scala/com/example/MySharedHelper.scala`, and provide a high-level description of the helper's purpose and signature. Atlas will then draft the Scala code for this new module. Crucially, every Atlas tool call, including `write`, is permission-gated. Before the file is created, Atlas will present a unified diff of the proposed changes, allowing you to review and approve the new Scala file's content and location. This ensures the new helper adheres to your project's `scalafmt` standards and integrates correctly with your existing `sbt` modules, traits, and implicits.
How to replace duplicated Scala code with a helper call using Atlas?
Replacing each instance of duplicated Scala code with a call to your new helper is managed by Atlas's `apply_patch` tool, which generates and applies one reviewable patch per file. This granular approach ensures that each modification, typically 3-5 lines of code, is independently verifiable and reversible, maintaining high confidence in your refactoring efforts.
After the shared Scala helper module is created, Atlas helps you replace each instance of the duplicated logic with a call to this new helper. The `apply_patch` tool is designed for this precise task. For each file containing the duplicated code, Atlas will compute a unified diff that replaces the old logic with a call to your `MySharedHelper.scala` function. Atlas surfaces this diff for your approval before writing any changes. This process generates one patch per file, making each swap independently reviewable and revertible. This is vital for complex Scala projects, as it allows you to incrementally apply changes and validate them. Atlas also snapshots file changes as git patches, so edits can be diffed and rolled back if needed, providing a robust safety net for your refactoring.
How to ensure Scala refactoring safety with Atlas and `sbt test`?
Ensuring the safety of your Scala refactoring is paramount, and Atlas integrates directly with your `sbt` build system to run `ScalaTest via sbt test` after every significant change. This immediate feedback loop, typically completing within 10-30 seconds for a focused test suite, confirms that your extracted helper maintains existing functionality.
Atlas prioritizes safety throughout the refactoring process. After each `apply_patch` operation that replaces duplicated Scala code with a helper call, Atlas recommends running your test suite. You can execute this directly using the `bash` tool within Atlas, for example, by running `atlas bash "sbt test"`. This command invokes `ScalaTest via sbt test`, providing immediate feedback on whether your changes have introduced regressions. Atlas's ability to read `git` branches, status, and diffs, and to stage and create commits on your behalf, further enhances safety. If a test fails, you can easily roll back the last patch. The final step in the workflow involves using `grep` to search for any surviving copies of the original duplicated logic, ensuring a complete and verified refactoring of your Scala codebase.
How does Atlas handle Scala project setup and context?
Atlas direct integrates with your Scala project by reading your `build.sbt` file and understanding your project's structure, including traits, implicits, and `sbt` modules. This setup, typically taking less than 5 minutes for an initial index, allows Atlas to provide context-aware refactoring suggestions and accurate code generation.
For Atlas to effectively assist with Scala refactoring, it needs to understand your project's context. The documented setup steps are straightforward: simply run `atlas` in a project with a `build.sbt` file. Atlas will then read your traits, implicits, and `sbt` modules, building a comprehensive index of your codebase. This indexing, which uses AST declarations via tree-sitter, provides Atlas with a deep semantic understanding of your Scala code, far beyond what a simple text search could achieve. This context allows Atlas to draft a plan in a read-only plan agent, asking for your approval before switching to a build agent to make changes. This deep understanding enables Atlas to not only extract helpers but also to refactor to typeclasses or add `ScalaTest` cases, always presenting a unified diff for your review.
Step by step
- 01Run `atlas codebase_search "find duplicated Scala logic for [describe behavior, not exact code]"` to identify near-duplicate implementations that `grep` would miss.
- 02Use `atlas read [file_path]` for each search hit to confirm the Scala code copies are genuinely equivalent and suitable for extraction.
- 03Create the shared Scala helper module with `atlas write src/main/scala/com/example/MySharedHelper.scala` (or your preferred path), reviewing the full diff in the permission prompt before creation.
- 04Replace each duplicate in a Scala file with a call to the new helper using `atlas apply_patch src/main/scala/com/example/OriginalFile1.scala`, reviewing each file's diff independently.
- 05After each `apply_patch` operation, run your ScalaTest suite with `atlas bash "sbt test"` to validate that no regressions were introduced.
- 06Repeat `atlas apply_patch` and `atlas bash "sbt test"` for all remaining duplicated Scala files.
- 07Finish by running `atlas bash "grep -r 'old_logic_pattern' src/main/scala"` to ensure no surviving copies of the original duplicated Scala logic remain.
- 08Use `atlas bash "scalafmt"` to ensure all modified Scala files adhere to your project's formatting standards before committing.
Frequently asked questions
- How does Atlas find Scala code duplication that `grep` misses?
- Atlas indexes Scala code by AST declarations using tree-sitter and employs hybrid semantic and keyword retrieval. This allows it to understand the *meaning* of your Scala code, surfacing near-duplicate logic even when variable names or minor syntax differ, which `grep` would typically miss.
- Can Atlas refactor Scala code with typeclasses?
- Yes, Atlas can refactor Scala code to typeclasses. Its deep understanding of Scala's structure, including traits and implicits, allows it to propose and implement such advanced refactorings, always presenting a diff for your review and approval.
- How does Atlas ensure safety when refactoring Scala files?
- Atlas ensures safety by drafting a plan in a read-only agent, asking for permission before any changes. It computes a unified diff for every file edit, which you must approve. It also allows you to run `ScalaTest via sbt test` after each change and snapshots file changes as git patches for easy rollback.
- What Scala build tools does Atlas support?
- Atlas is designed to work with Scala projects built using `sbt`. It reads your `build.sbt` file to understand your project's structure, modules, and dependencies, integrating direct with your existing `sbt` workflow.
- Can I review Atlas's Scala code changes before they are applied?
- Absolutely. Atlas computes a unified diff for every file edit it proposes, whether creating a new `src/main/scala` file or modifying an existing one. This diff is surfaced for your explicit approval before any changes are written to your Scala codebase.
- Does Atlas support Scala code formatting with `scalafmt`?
- Yes, Atlas respects your project's formatting standards. While it drafts code, you can use `atlas bash "scalafmt"` as part of your workflow to ensure all generated or modified Scala code adheres to your `scalafmt` configuration before committing.
- Can Atlas help with adding new ScalaTest cases?
- Yes, Atlas can assist with adding new `ScalaTest` cases. Given its understanding of your Scala project's context and existing tests, it can draft new test cases to cover specific functionality or regressions, which you can then review and integrate.
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 Scala in 2026
Atlas is a terminal-native AI coding agent for Scala in 2026. Run it in a project with a build.sbt, let it read your traits and implicits, and approve every diff.
Diagnose a hanging or long-running command in Scala with Atlas (2026)
Is your sbt build slow or blocked on stdin? Atlas races every command against a timeout and tells you which. A 2026 guide for Scala teams using sbt and scalafmt.
Audit a Scala Repo with Parallel Subagents in Atlas, 2026
In 2026, Scala developers use Atlas to sweep entire repositories for code problems without context window limits. Launch parallel subagents for efficient, read-only audits of Scala projects.
Migrate a deprecated API across every callsite in Scala with Atlas in 2026
Effortlessly migrate deprecated Scala APIs across your entire codebase using Atlas. Discover every callsite, apply context-aware patches, and verify with `sbt test` for a complete, safe transition in 2026.
Rename a symbol across the repo in Scala with Atlas in 2026
Refactor Scala code with Atlas in 2026. Safely rename functions, classes, or constants across your entire sbt project, ensuring all references, including comments and strings, are updated accurately.
Debug a Single Failing Test in Scala with Atlas (2026)
How Atlas debugs one failing Scala test in 2026: run it isolated with sbt, walk the call path with the lsp tool, and fix the code, not the assertion.
Write Unit Tests for Untested Code in Scala with Atlas (2026)
How to add ScalaTest coverage to an untested Scala module with Atlas in 2026: enumerate symbols with lsp documentSymbol, copy repo conventions, then run sbt test.