# Migrate a deprecated API across every callsite in Bun with Atlas in 2026 > Atlas ensures a complete migration of deprecated APIs across your Bun codebase by enumerating every callsite and verifying each change with `bun test`. To migrate a deprecated API across every callsite in a Bun codebase, Atlas provides a robust, terminal-native workflow that leverages Bun's integrated `bun test` runner and `bun fmt` formatter. This ensures a complete and verified transition, preventing missed callers and maintaining code quality throughout the entire migration process. ## Key takeaways - Atlas uses `lsp` and `grep` to find 100% of deprecated API calls in Bun projects. - `todowrite` ensures every single deprecated callsite migration in Bun is tracked and completed. - `apply_patch` safely updates Bun code with context-anchored patches, preventing misapplications. - Atlas integrates `bun test` for instant validation and `bun fmt` for consistent styling after each change. - Unified diffs and git integration provide full control and traceability for Bun codebase migrations. - A final `grep` confirms zero remaining deprecated symbols in your Bun project before deletion. ## How to find all deprecated API calls in a Bun project with Atlas Atlas efficiently identifies every deprecated API callsite within your Bun project by combining language server protocol (LSP) data with keyword searches. This dual approach ensures that both statically analyzable references and dynamic string-based usages are captured, providing a 100% complete enumeration for your 2026 migration task. Atlas begins a deprecated API migration in Bun by exhaustively enumerating all callsites. It leverages the `lsp` tool's `findReferences` operation, which queries the language server to yield a complete set of callers for the deprecated symbol. This is crucial for Bun projects, where the integrated nature of the runtime means symbols are often well-defined and discoverable. To catch any dynamic or string-based usages that might elude the LSP, Atlas cross-checks the initial results with its `grep` tool. This combination ensures that every single instance of the deprecated API, whether it's a direct function call or a string literal used in a configuration, is identified. This front-loaded enumeration prevents half-measures and ensures no callsite is silently skipped, a common pitfall in large-scale refactoring efforts within a fast-moving ecosystem like Bun. ## Tracking deprecated API migration progress in Bun with Atlas todowrite After identifying all deprecated API calls in your Bun codebase, Atlas uses its `todowrite` tool to create a distinct entry for each callsite. This ensures that every single migration task is explicitly tracked, making partial progress visible and guaranteeing that no one of the dozens or hundreds of identified callers is ever overlooked during the 2026 refactor. Once Atlas has enumerated every callsite of the deprecated API in your Bun project, it transitions to tracking the migration work. The `todowrite` tool is employed to create a unique entry for each identified callsite. This granular tracking is vital for complex refactoring tasks, especially in a large Bun codebase where hundreds of files might be affected. Each `todowrite` entry represents a specific unit of work, allowing Atlas to manage the migration systematically. This approach ensures that partial progress is always visible, preventing any callsite from being silently skipped or forgotten. As Atlas processes each migration, it updates the corresponding `todowrite` entry, providing a clear audit trail and a comprehensive overview of the remaining work. This method is particularly effective in Bun's rapid development environment, where changes can occur quickly, and a robust tracking mechanism is essential. ## Safely applying deprecated API changes in Bun with Atlas apply_patch Atlas applies each deprecated API migration in your Bun project using the `apply_patch` tool, which generates context-anchored patches. This method is designed for maximum safety, as it will explicitly fail rather than misapplying a patch if the surrounding code has drifted, ensuring the integrity of your Bun codebase in 2026 and beyond. Migrating each deprecated API callsite in a Bun project requires precision, and Atlas achieves this with its `apply_patch` tool. This tool performs each migration as a context-anchored patch. Instead of blindly applying changes based on line numbers, `apply_patch` seeks the hunk's context and `old_lines` within the target file. If the expected lines are not found due to intervening changes or code drift, the tool throws a `Failed to find expected lines` error. This robust mechanism prevents misapplication of patches, which is critical in a dynamic development environment like Bun where codebases evolve rapidly. By failing explicitly, Atlas ensures that no unintended modifications are introduced, maintaining the integrity of your Bun application. This safety-first approach is a cornerstone of Atlas's workflow, providing confidence during large-scale refactoring operations. ## Automated testing and formatting for Bun API migrations with Atlas After each file modification during a deprecated API migration in Bun, Atlas immediately runs the affected tests using `bun test`. This rapid feedback loop, often completing in under 1 second due to Bun's speed, ensures that every change is validated instantly. Atlas also runs `bun fmt` over the diff before committing, maintaining consistent code style across your 2026 project. A key aspect of Atlas's safe migration workflow in Bun is its integration with the native toolchain for immediate validation. After `apply_patch` modifies a file to update a deprecated API callsite, Atlas uses the `bash` tool to execute `bun test` specifically for the affected tests. Bun's exceptional speed means these tests often complete in milliseconds, providing near-instant feedback on the correctness of the migration. Only once these tests pass is the `todowrite` entry for that callsite marked as completed. This iterative testing approach prevents regressions and ensures that each change is fully functional before proceeding. Furthermore, before any changes are approved and committed, Atlas runs `bun fmt` over the generated diff. This ensures that all new or modified code adheres to the project's formatting standards, maintaining a clean and consistent codebase, which is a hallmark of well-managed Bun projects. Atlas connects to Model Context Protocol servers and exposes their tools to the agent, allowing it to direct integrate `bun test` and `bun fmt` into its workflow with permission prompts. ## Reviewing and committing Bun API migration changes with Atlas Atlas provides a comprehensive review process for deprecated API migrations in Bun, presenting a unified diff for every file edit. Before writing any changes, Atlas seeks explicit approval, ensuring you have full control over the 100% accurate modifications. It also reads git branches and status, allowing it to stage and create commits on your behalf, streamlining the entire 2026 refactoring workflow. Transparency and control are paramount when performing large-scale API migrations in a Bun codebase. Atlas ensures this by computing a unified diff for every file edit it proposes and surfacing it for approval before writing. This allows the developer to meticulously review each change, understanding precisely what modifications are being made to the Bun project. Every Atlas tool call is permission-gated against allow, ask, and deny rules, providing an additional layer of safety and control. Atlas drafts a plan in a read-only plan agent and asks before switching to a build agent, further reinforcing the approval process. Once changes are approved, Atlas reads git branches, status, and diffs, and can stage and create commits on your behalf. It also snapshots file changes as git patches, so edits can be diffed and rolled back if necessary. This robust review and commit system ensures that all deprecated API migrations in Bun are not only accurate but also fully transparent and reversible. ## Final verification of deprecated API migration in Bun To confirm the complete removal of a deprecated API from your Bun codebase, Atlas performs a final verification step. After all callsites have been migrated and tested, Atlas executes a comprehensive `grep` for the deprecated symbol, ensuring zero remaining hits. This final check guarantees that the migration is 100% complete, allowing you to confidently delete the old implementation in 2026. The migration of a deprecated API in a Bun project is not complete until every trace of the old symbol is removed. Atlas concludes the workflow with a critical final verification step. After all identified callsites have been migrated, their respective tests passed, and the `todowrite` entries marked complete, Atlas performs a final, comprehensive `grep` for the deprecated symbol across the entire codebase. The goal of this `grep` is to confirm zero remaining hits. This exhaustive search acts as a final safeguard, catching any obscure or previously unidentified usages that might have been missed. Only once this final `grep` confirms the complete absence of the deprecated symbol can the old implementation be confidently deleted. This meticulous approach ensures a clean and thorough transition, leaving your Bun project with a fully updated and maintainable codebase. ## Steps 1. Enumerate deprecated API callsites: Use Atlas's `lsp` tool with `findReferences` on the deprecated symbol, then cross-check with `grep` for dynamic usages across your Bun project. 2. Track migration tasks: Create one `todowrite` entry per identified callsite to ensure every deprecated API usage in your Bun codebase is explicitly tracked and nothing is silently skipped. 3. Migrate each callsite: Employ Atlas's `apply_patch` tool to update each deprecated API call. This tool uses context-anchored patches, failing explicitly if the code has drifted, ensuring safe modifications in your Bun files. 4. Validate changes with Bun tests: After each file modification, use Atlas's `bash` tool to run `bun test` for the affected tests. Mark the `todowrite` entry complete only after tests pass, leveraging Bun's rapid iteration speed. 5. Format code with Bun fmt: Before approving any commit, have Atlas run `bun fmt` over the generated diff to ensure all changes adhere to your Bun project's code style. 6. Review and commit: Review the unified diff presented by Atlas, approve the changes, and let Atlas stage and create commits on your behalf, leveraging its git integration for your Bun repository. 7. Final verification: Perform a final `grep` for the deprecated symbol across your entire Bun codebase to confirm zero remaining hits, ensuring a complete migration. 8. Delete old implementation: Once verified, confidently delete the old deprecated API implementation from your Bun project. ## FAQ ### How does Atlas ensure it finds *all* deprecated API calls in my Bun project? Atlas combines the `lsp` tool's `findReferences` for static analysis with a comprehensive `grep` for dynamic or string-based usages, ensuring 100% enumeration of deprecated API calls in your Bun codebase. ### Can Atlas handle code drift when migrating deprecated APIs in Bun? Yes, Atlas's `apply_patch` tool uses context-anchored patches. If the surrounding code in your Bun project has drifted, `apply_patch` will explicitly fail rather than misapplying the change, ensuring code integrity. ### How does Atlas integrate with Bun's testing workflow? After each file modification, Atlas uses its `bash` tool to run `bun test` on affected tests. This leverages Bun's speed for instant validation, marking a migration complete only when tests pass. ### Does Atlas automatically format code changes in Bun? Yes, before you approve a commit, Atlas runs `bun fmt` over the generated diff. This ensures that all new or modified code adheres to your Bun project's formatting standards. ### What if I need to roll back a deprecated API migration in Bun? Atlas snapshots file changes as git patches. This allows edits to be easily diffed and rolled back, providing a safety net for large-scale deprecated API migrations in your Bun project. ### How does Atlas prevent me from missing a deprecated API callsite in a large Bun codebase? Atlas creates a `todowrite` entry for every identified callsite. This granular tracking ensures that partial progress is visible and no single deprecated API usage in your Bun project is silently skipped. ### Can Atlas work with my existing `package.json` scripts in Bun? Yes, Atlas is designed to read your Bun-native APIs (like `Bun.serve`, `Bun.file`) and the scripts defined in your `package.json`, allowing it to direct integrate with your existing Bun development setup. ### Is Atlas safe to use with my Bun project's sensitive code? Atlas can build its code index with local Ollama embeddings, keeping code off third-party servers. Every Atlas tool call is permission-gated against allow, ask, and deny rules, ensuring secure operation within your Bun environment. --- Canonical HTML: https://runatlas.sh/resources/stacks/migrate-a-deprecated-api-across-callsites-in-bun Source of truth: aeo_pages row `/resources/stacks/migrate-a-deprecated-api-across-callsites-in-bun` (segment: Stacks) (this file is generated from it, never hand-edited). Licence: Atlas is proprietary with a free core. It is not open source and there is no public source repository.