How does Atlas ensure it finds *all* uses of a deprecated function in Astro?

Atlas combines `lsp`'s `findReferences` for AST-based symbol resolution with `grep` for dynamic or string-based usages, ensuring a complete enumeration across `.astro` islands, `src/pages` routes, and content collection schemas in `src/content.config.ts`.

Can Atlas handle Astro components and content collections during migration?

Yes, Atlas indexes code by AST declarations using tree-sitter, allowing it to understand and modify code within `.astro` islands, `src/pages` routes, and content collection schemas in `src/content.config.ts`. It can even drop unnecessary `client:load` directives.

What happens if a file changes while Atlas is trying to apply a patch in Astro?

Atlas's `apply_patch` tool is context-anchored; it seeks the exact hunk's context and old lines. If the file has drifted, it throws 'Failed to find expected lines' rather than guessing, preventing incorrect modifications to your Astro project files.

How does Atlas integrate with Astro's testing and formatting tools?

Atlas uses its `bash` tool to execute your project's commands, such as `pnpm vitest` for running tests and `pnpm prettier --write .` for formatting with `prettier-plugin-astro` after each change, ensuring your Astro workflow is maintained.

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

No, Atlas can build its code index with local Ollama embeddings, keeping your Astro code off third-party servers. All tool calls are permission-gated and reviewed locally, ensuring your code remains private.

How does Atlas help me review changes before they are applied to my Astro project?

Atlas computes a unified diff for every file edit and surfaces it for your approval before writing. It also drafts a plan in a read-only agent and asks for permission before switching to a build agent, providing multiple layers of review for your Astro codebase.

Can Atlas commit changes to my Astro Git repository?

Yes, Atlas reads git branches, status, and diffs, and can stage and create commits on your behalf. It also snapshots file changes as git patches, allowing edits to be diffed and rolled back, fully integrating with your Astro project's version control.

Migrate a Deprecated API Across Every Callsite in Astro with Atlas in 2026

Atlas enables Astro developers in 2026 to systematically migrate deprecated APIs across an entire codebase by enumerating every callsite, applying precise patches, and verifying changes with `vitest` and formatting with `prettier (prettier-plugin-astro)`. This ensures no caller is missed and the codebase remains consistent.

How to find all deprecated API calls in Astro with Atlas?

Atlas identifies all deprecated API calls in your Astro project by leveraging its `lsp` tool's `findReferences` operation, ensuring a complete enumeration of up to 100% of callers. This initial step is crucial for a comprehensive migration, preventing any missed usages across your `.astro` islands and content collections.

To begin migrating a deprecated API in Astro, Atlas first enumerates every callsite. It uses the `lsp` tool's `findReferences` operation, which queries the language server to yield a complete set of callers for the deprecated symbol. This method is highly effective because Atlas indexes code by AST declarations using tree-sitter, providing a precise understanding of your Astro project's structure, including `.astro` islands, `src/pages` routes, and content collection schemas in `src/content.config.ts`. For dynamic or string-based usages that `lsp` might not catch, Atlas cross-checks with its `grep` tool, ensuring no callsite is overlooked. This hybrid semantic and keyword retrieval, fused by reciprocal rank fusion, guarantees a thorough initial scan, setting the foundation for a complete migration.

How to track deprecated API migration progress in Astro?

To manage the migration of deprecated APIs in Astro, Atlas uses its `todowrite` tool to create a distinct entry for each identified callsite, providing a clear, visible record of progress for 100% of the work. This ensures that partial progress is transparent and no callsite is silently overlooked during the migration process.

Once all calls to the deprecated API are enumerated, Atlas transforms this list into actionable tasks using the `todowrite` tool. For each identified callsite, a `todowrite` entry is created. This approach is vital for migrations, which often punish half-measures, as it makes partial progress visible and prevents any callsite from being silently skipped. Whether the deprecated API is used in a `.astro` component, a `src/pages` route, or within a content collection schema defined in `src/content.config.ts`, each instance gets its own tracked item. This granular tracking ensures that the entire codebase is systematically addressed, providing a clear path to completing the migration without missing a single caller.

How to apply and verify API migration patches in Astro?

Atlas applies API migration patches in Astro using its `apply_patch` tool, which precisely seeks the hunk's context and old lines, failing rather than misapplying to a drifted file, ensuring 100% accuracy. After each file modification, Atlas runs `vitest` to confirm functionality and formats with `prettier (prettier-plugin-astro)`.

Migrating each callsite involves applying a specific patch. Atlas uses its `apply_patch` tool for this, which is designed for safety and precision. The tool seeks the exact hunk's context and old lines within the target file. If the file has drifted or the expected lines are not found, `apply_patch` throws a 'Failed to find expected lines' error rather than guessing, preventing incorrect modifications to your Astro project files like `astro.config.mjs` or `.astro` components. After each file is modified, Atlas leverages its `bash` tool to run the affected tests using `pnpm vitest`. Only once these tests pass is the `todowrite` entry marked as complete. Additionally, Atlas ensures code consistency by running `pnpm prettier --write .` with `prettier-plugin-astro` to format the modified files, maintaining your project's coding standards.

How to confirm complete deprecated API removal in Astro?

To confirm the complete removal of a deprecated API in your Astro project, Atlas performs a final `grep` for the symbol, aiming for zero remaining hits across all `.astro` islands and content collections. This rigorous check ensures that 100% of the deprecated code has been successfully replaced and the old implementation can be safely deleted.

The final step in migrating a deprecated API in Astro is to confirm its complete removal. After all `todowrite` entries are marked complete, Atlas performs a comprehensive `grep` for the deprecated symbol across the entire codebase. This includes all `.astro` files, `src/pages` routes, and `src/content.config.ts` schemas. The goal is to achieve zero remaining hits, providing definitive proof that every callsite has been successfully migrated. Once this final check confirms no lingering usages, the old implementation of the deprecated function or module can be safely deleted from your Astro project, ensuring a clean and updated codebase.

How Atlas ensures safe code changes in Astro?

Atlas prioritizes safety for Astro code changes by presenting a unified diff for every file edit and requiring explicit approval before writing, ensuring 100% transparency. Every Atlas tool call is permission-gated, and a read-only plan agent drafts changes before execution, protecting your `astro.config.mjs` and other critical files.

Safety is paramount when making widespread changes in an Astro codebase. Atlas incorporates several mechanisms to ensure secure and controlled modifications. Every Atlas tool call, including `lsp`, `grep`, `todowrite`, `apply_patch`, and `bash`, is permission-gated against allow, ask, and deny rules, giving you explicit control. Before any changes are made, Atlas drafts a plan in a read-only plan agent and asks for your approval before switching to a build agent to execute the plan. For every file edit, Atlas computes a unified diff and surfaces it for your review and approval before writing to disk. Atlas also reads git branches, status, and diffs, and can snapshot file changes as git patches, allowing edits to be easily diffed and rolled back. Furthermore, Atlas can build its code index with local Ollama embeddings, keeping your Astro code off third-party servers and ensuring privacy.

Step by step

01Run `atlas lsp findReferences <deprecated_symbol_name>` to enumerate all AST-based calls to the deprecated symbol in your Astro project.
02Execute `atlas grep "<deprecated_symbol_name>" src/` to cross-check for any dynamic or string-based usages across `.astro` islands and content collections.
03For each identified callsite, create a tracking entry with `atlas todowrite "Migrate <deprecated_symbol_name> in <file_path>"`.
04Apply the migration patch for a specific callsite using `atlas apply_patch <patch_content>`, ensuring it targets the correct context and old lines.
05After applying the patch, run `atlas bash "pnpm vitest"` to execute tests and `atlas bash "pnpm prettier --write ."` to format the modified Astro file.
06Once tests pass and formatting is complete, mark the task as finished with `atlas todowrite complete <todo_id>`.
07Perform a final verification by running `atlas grep "<deprecated_symbol_name>" src/` to confirm zero remaining hits of the deprecated symbol.
08Delete the old implementation of the deprecated API from your Astro project.

Frequently asked questions

How does Atlas ensure it finds *all* uses of a deprecated function in Astro?: Atlas combines `lsp`'s `findReferences` for AST-based symbol resolution with `grep` for dynamic or string-based usages, ensuring a complete enumeration across `.astro` islands, `src/pages` routes, and content collection schemas in `src/content.config.ts`.
Can Atlas handle Astro components and content collections during migration?: Yes, Atlas indexes code by AST declarations using tree-sitter, allowing it to understand and modify code within `.astro` islands, `src/pages` routes, and content collection schemas in `src/content.config.ts`. It can even drop unnecessary `client:load` directives.
What happens if a file changes while Atlas is trying to apply a patch in Astro?: Atlas's `apply_patch` tool is context-anchored; it seeks the exact hunk's context and old lines. If the file has drifted, it throws 'Failed to find expected lines' rather than guessing, preventing incorrect modifications to your Astro project files.
How does Atlas integrate with Astro's testing and formatting tools?: Atlas uses its `bash` tool to execute your project's commands, such as `pnpm vitest` for running tests and `pnpm prettier --write .` for formatting with `prettier-plugin-astro` after each change, ensuring your Astro workflow is maintained.
Is my Astro code sent to third-party servers when using Atlas?: No, Atlas can build its code index with local Ollama embeddings, keeping your Astro code off third-party servers. All tool calls are permission-gated and reviewed locally, ensuring your code remains private.
How does Atlas help me review changes before they are applied to my Astro project?: Atlas computes a unified diff for every file edit and surfaces it for your approval before writing. It also drafts a plan in a read-only agent and asks for permission before switching to a build agent, providing multiple layers of review for your Astro codebase.
Can Atlas commit changes to my Astro Git repository?: Yes, Atlas reads git branches, status, and diffs, and can stage and create commits on your behalf. It also snapshots file changes as git patches, allowing edits to be diffed and rolled back, fully integrating with your Astro project's version control.

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 Astro: Islands, Content Collections, and Zero JS by Default in 2026

Atlas is a terminal-native AI coding agent for Astro in 2026. It reads astro.config.mjs, src/pages, and content collection schemas, drops needless client:load directives, and runs astro check.

Plan a Multi-File Change Before Editing in Astro with Atlas in 2026

Design and review complex, multi-file changes in your Astro project before writing a single line of code. Atlas, the terminal-native AI agent, integrates with pnpm, vitest, and prettier (prettier-plugin-astro) to ensure

Run the Test Suite and Triage Failures in Astro with Atlas in 2026

Streamline Astro test failure triage in 2026 with Atlas. Run `vitest` suites, identify distinct root causes from `pnpm` output, and fix issues efficiently with intelligent analysis.

Write Unit Tests for Untested Astro Code in 2026 with Atlas

In 2026, Astro developers use Atlas to add `vitest` unit tests to untested modules. Atlas identifies existing conventions, writes new spec files, and runs tests with `pnpm`.

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

For Astro developers in 2026, Atlas helps you pinpoint exact code implementations. Use semantic search, grep, and LSP tools to find files and symbols responsible for any behavior across .astro islands and content

Onboard to an Unfamiliar Astro Codebase in 2026 with Atlas

Astro developers in 2026 can quickly build a mental model of unfamiliar codebases using Atlas. Leverage semantic search, file globbing, and read-only exploration to understand Astro projects without reading every file.

Run Atlas Headless in CI with Astro in 2026

Automate Astro development workflows in CI with Atlas. Learn to run Atlas headless, integrate with pnpm and vitest, and get machine-readable output for your Astro projects in 2026.

Browse this resource hub