How does Atlas ensure it finds all deprecated API calls in a Nuxt 3 project?

Atlas combines `lsp findReferences` for precise language server-based symbol resolution across Nuxt's auto-imports and components, with `grep` for catching dynamic or string-based usages in `.vue` templates, `server/api/` handlers, or `nuxt.config.ts`, ensuring comprehensive coverage.

Can Atlas handle migrations in Nuxt files like pages/, composables/, or server/api/?

Yes, Atlas is designed to respect Nuxt's file-based routing, auto-imports, and the Nitro server/client split. It understands the context of `.vue` components, `composables/` functions, and `server/api/` route handlers, applying changes appropriately.

What happens if a Nuxt file changes while Atlas is working on a migration?

Atlas's `apply_patch` tool is robust. It computes context-anchored patches and explicitly verifies the `old_lines` before applying changes. If a Nuxt file has drifted, `apply_patch` will fail with "Failed to find expected lines" rather than misapplying the patch, ensuring data integrity.

How does Atlas integrate with Nuxt's testing setup?

Atlas uses its `bash` tool to execute `pnpm vitest` through `@nuxt/test-utils` after each file modification. This ensures that any regressions introduced by the API migration in your Nuxt project are caught immediately, and the `todowrite` entry is only marked complete upon test success.

Does Atlas help maintain code style in my Nuxt project during migration?

Absolutely. After applying changes to `.vue` or `.ts` files, Atlas can automatically run `pnpm prettier --write ` to format the touched code. This ensures that your Nuxt codebase remains consistent with your project's `prettier` configuration throughout the migration process.

How do I review the changes Atlas makes to my Nuxt codebase?

Atlas computes a unified diff for every file edit it proposes. Before writing any changes to your Nuxt project, it surfaces this diff for your approval. You have full control to review and accept or reject each modification.

Can Atlas help with committing the changes after a Nuxt API migration?

Yes, Atlas reads git branches, status, and diffs. Once the migration is complete and approved, Atlas can stage the file changes and create commits on your behalf, providing a clear and organized history of the entire Nuxt API migration.

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

Migrating a deprecated API across every callsite in a Nuxt project in 2026 is streamlined with Atlas, which leverages Nuxt's specific toolchain to ensure comprehensive updates. Atlas integrates directly with your `nuxt.config.ts` and understands Nuxt's file-based routing, auto-imports, and Nitro server/client split. It uses `lsp` to enumerate all callers, `todowrite` to track progress, `apply_patch` for precise modifications, and `bash` to run `pnpm vitest` after each change, ensuring no regressions.

How to find all deprecated API calls in Nuxt 3?

Identifying every callsite of a deprecated API in your Nuxt 3 project is the critical first step, preventing missed updates. Atlas achieves this by combining `lsp` for precise language server references with `grep` for dynamic or string-based usages, ensuring 100% coverage across your `.vue` components and `.ts` files.

Atlas begins by leveraging the `lsp` tool's `findReferences` operation. This directly queries the language server, which has a deep understanding of your Nuxt project's `composables/` auto-imports, `pages/` routes, and `server/api/` Nitro handlers. For instance, if you're deprecating a utility function in `utils/old-helper.ts`, Atlas will ask the language server for every file that imports or calls it. To catch any edge cases, such as dynamic imports, string literals, or template usages that the language server might not fully resolve, Atlas then cross-checks with a `grep` search for the deprecated symbol's name. This dual approach guarantees that whether the call is in a `<script setup>` block of a `.vue` file, a `server/api/` handler, or a `plugins/` file, Atlas will find it. This comprehensive enumeration is crucial for a migration that leaves zero remaining hits of the old API.

How Atlas tracks migration progress for deprecated Nuxt functions?

Tracking the migration of each deprecated function call in Nuxt is essential for managing large-scale refactors and ensuring no callsite is overlooked. Atlas uses its `todowrite` tool to create a distinct entry for every identified callsite, providing a clear, visible roadmap for the 2026 migration effort.

Once Atlas has enumerated all calls to the deprecated API across your Nuxt project, it automatically creates a `todowrite` entry for each one. This isn't just a checklist; it's a structured way to manage the migration workflow. Each entry represents a specific file and line number where a change needs to occur, for example, in a `pages/index.vue` component or a `server/api/data.ts` endpoint. As Atlas processes each callsite, it updates the status of its corresponding `todowrite` entry. This allows you to see partial progress, understand the remaining workload, and ensures that no callsite is silently skipped or forgotten. This granular tracking is particularly valuable in complex Nuxt applications with many components and modules, where a single deprecated function might be used in dozens of locations.

How Atlas safely migrates Nuxt API calls with precise patches?

Safely migrating each deprecated API call in your Nuxt codebase requires precision to avoid introducing new bugs or misapplying changes. Atlas employs its `apply_patch` tool, which generates context-anchored patches that explicitly seek the old lines, failing rather than guessing, ensuring a 100% reliable update process.

For each `todowrite` entry, Atlas uses its `apply_patch` tool to perform the actual migration. This tool is designed for robustness: it doesn't just apply a change blindly. Instead, it computes a unified diff that includes context lines around the change. When applying the patch, `apply_patch` explicitly verifies that the `old_lines` it expects to modify are still present and exactly match the current file content. If the file has drifted due to other changes, `apply_patch` will throw a "Failed to find expected lines" error, preventing a misapplication. This ensures that modifications to your Nuxt `.vue` components, `composables/` files, or `server/api/` routes are always accurate. After the patch is applied, Atlas can then run `prettier` over the touched `.vue` and `.ts` files to maintain consistent code style across your project, as defined in your `prettier.config.js` or `.prettierrc`.

How to validate Nuxt API migrations with vitest and prettier?

Validating each API migration in Nuxt immediately after applying a patch is crucial for maintaining code quality and preventing regressions. Atlas integrates `bash` to run `pnpm vitest` via `@nuxt/test-utils` after every file modification, ensuring that your 2026 codebase remains stable and correctly formatted with `prettier`.

After Atlas applies a patch to a Nuxt file, such as a `pages/products/[id].vue` component or a `server/api/items.ts` handler, it immediately executes the relevant tests. Atlas uses the `bash` tool to run `pnpm vitest` through `@nuxt/test-utils`, targeting only the affected tests. This rapid feedback loop is vital: if a migration introduces a bug, Atlas will detect it instantly, preventing the issue from propagating. Only once the tests pass for that specific file is the `todowrite` entry marked as complete. Furthermore, Atlas ensures that all touched `.vue` and `.ts` files are automatically formatted using `prettier`. This step, executed via `pnpm prettier --write <file>`, guarantees that your Nuxt project adheres to its established coding standards throughout the migration, maintaining a clean and consistent codebase.

How Atlas ensures a complete Nuxt API migration and final cleanup?

Ensuring a complete migration of a deprecated API across your Nuxt project means confirming zero remaining calls and cleaning up the old implementation. Atlas concludes the workflow by performing a final `grep` for the deprecated symbol and, upon confirmation, assists in deleting the old code, solidifying the 2026 update.

The final stage of migrating a deprecated API in Nuxt with Atlas involves a rigorous verification process. After all `todowrite` entries are marked complete and all tests have passed, Atlas performs a final, comprehensive `grep` search across your entire Nuxt project for the deprecated symbol. This acts as a double-check, catching any obscure or dynamically generated usages that might have been missed. Once this `grep` confirms zero remaining hits of the old API, Atlas can then assist in deleting the old implementation file, for example, `utils/deprecated-function.ts`. This ensures that your Nuxt application, including its `pages/`, `composables/`, and `server/api/` directories, is entirely free of the deprecated code, completing the migration and preventing future accidental usage. Atlas's ability to read git branches and status also allows it to stage and create commits on your behalf, providing a clear audit trail for the entire migration.

Step by step

01Enumerate all deprecated API calls in your Nuxt project: Use `atlas lsp findReferences <deprecated-symbol>` to get a complete list of callers from the language server, then cross-check with `atlas grep "<deprecated-symbol-name>"` to find dynamic or string-based usages across your `.vue` and `.ts` files.
02Create a `todowrite` entry for each callsite: Let Atlas automatically generate `todowrite` entries for every identified call, ensuring visible progress tracking for each instance in your Nuxt `pages/`, `composables/`, or `server/api/` directories.
03Migrate each callsite with `apply_patch`: Instruct Atlas to use `apply_patch` to modify each file. Atlas will compute a context-anchored patch, seeking the exact `old_lines` in your Nuxt `.vue` or `.ts` files and failing if the context has drifted, preventing incorrect changes.
04Run Nuxt tests and format after each file: After Atlas applies a patch to a file, it will use `atlas bash "pnpm vitest <affected-test-file>"` via `@nuxt/test-utils` to run relevant tests. Once tests pass, Atlas will run `atlas bash "pnpm prettier --write <touched-file>"` to format the code.
05Review the unified diff and approve changes: Atlas will present a unified diff for each file edit. Review the changes to your Nuxt components or API handlers and approve them before Atlas writes to disk.
06Confirm zero remaining deprecated symbols: After all `todowrite` entries are complete, run `atlas grep "<deprecated-symbol-name>"` one final time to confirm no instances of the old API remain in your Nuxt codebase.
07Delete the old implementation: Once confirmed, instruct Atlas to remove the deprecated function or module file, for example, `utils/old-function.ts`, from your Nuxt project.

Frequently asked questions

How does Atlas ensure it finds all deprecated API calls in a Nuxt 3 project?: Atlas combines `lsp findReferences` for precise language server-based symbol resolution across Nuxt's auto-imports and components, with `grep` for catching dynamic or string-based usages in `.vue` templates, `server/api/` handlers, or `nuxt.config.ts`, ensuring comprehensive coverage.
Can Atlas handle migrations in Nuxt files like pages/, composables/, or server/api/?: Yes, Atlas is designed to respect Nuxt's file-based routing, auto-imports, and the Nitro server/client split. It understands the context of `.vue` components, `composables/` functions, and `server/api/` route handlers, applying changes appropriately.
What happens if a Nuxt file changes while Atlas is working on a migration?: Atlas's `apply_patch` tool is robust. It computes context-anchored patches and explicitly verifies the `old_lines` before applying changes. If a Nuxt file has drifted, `apply_patch` will fail with "Failed to find expected lines" rather than misapplying the patch, ensuring data integrity.
How does Atlas integrate with Nuxt's testing setup?: Atlas uses its `bash` tool to execute `pnpm vitest` through `@nuxt/test-utils` after each file modification. This ensures that any regressions introduced by the API migration in your Nuxt project are caught immediately, and the `todowrite` entry is only marked complete upon test success.
Does Atlas help maintain code style in my Nuxt project during migration?: Absolutely. After applying changes to `.vue` or `.ts` files, Atlas can automatically run `pnpm prettier --write <file>` to format the touched code. This ensures that your Nuxt codebase remains consistent with your project's `prettier` configuration throughout the migration process.
How do I review the changes Atlas makes to my Nuxt codebase?: Atlas computes a unified diff for every file edit it proposes. Before writing any changes to your Nuxt project, it surfaces this diff for your approval. You have full control to review and accept or reject each modification.
Can Atlas help with committing the changes after a Nuxt API migration?: Yes, Atlas reads git branches, status, and diffs. Once the migration is complete and approved, Atlas can stage the file changes and create commits on your behalf, providing a clear and organized history of the entire Nuxt API migration.

Try Atlas in your terminal

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

Install Atlas

Related guides

Migrate a Deprecated API Across Every Callsite with Atlas (2026 Workflow)

How to migrate a deprecated API across every callsite with Atlas in 2026: the lsp tool's findReferences enumerates callers, todowrite tracks them, apply_patch migrates each one.

Atlas for Nuxt: Auto-Imports, useAsyncData, and Nitro Handlers in 2026

Atlas is a terminal-native AI coding agent for Nuxt in 2026. It reads nuxt.config.ts, pages/ routes, composables/ auto-imports, and server/api/ Nitro handlers, and tests with @nuxt/test-utils.

Self-review Your Working Diff Before Committing in Nuxt with Atlas in 2026

Catch your own mistakes in uncommitted Nuxt diffs before they reach review or CI. Use Atlas to review changes, run vitest, pnpm, and prettier, and safely revert unwanted edits.

Audit a Nuxt.js Repository with Parallel Subagents in 2026 using Atlas

Sweep your Nuxt.js repository for issues without context window limits. Atlas uses parallel subagents to audit code, respecting Nuxt's file-based routing and auto-imports.

Write unit tests for untested code in Nuxt with Atlas in 2026

Learn how Atlas helps Nuxt developers in 2026 add real unit tests to untested modules using `vitest (@nuxt/test-utils)`, `pnpm`, and `prettier`, matching existing repo conventions.

Review a Pull Request in Nuxt with Atlas in 2026

In 2026, Nuxt developers use Atlas to review pull requests, leveraging its AI to understand diffs with full context. Atlas integrates with `pnpm`, `vitest (@nuxt/test-utils)`, and `prettier` to ensure robust code

Onboard to an Unfamiliar Nuxt Codebase with Atlas in 2026

Quickly build a working mental model of any Nuxt.js repository using Atlas. Leverage semantic search, AST indexing, and permission-gated tools to understand file-based routing, auto-imports, and Nitro handlers without

Debug a single failing test in Nuxt with Atlas in 2026

Pinpoint and fix failing Nuxt tests with Atlas in 2026. Leverage vitest (@nuxt/test-utils) and pnpm for efficient debugging, code navigation, and precise fixes in your Nuxt 3 application.

Browse this resource hub