# Review a Pull Request in Astro with Atlas in 2026 > Atlas empowers Astro developers to review pull requests thoroughly, leveraging `vitest` for testing and `prettier (prettier-plugin-astro)` for consistent formatting across their projects. Atlas helps Astro developers review pull requests by fetching diffs, reading full files, checking references with the `lsp` tool, and running `vitest` tests, all while respecting the `pnpm` package manager and `prettier (prettier-plugin-astro)` formatting. This ensures a thorough review that goes beyond line-by-line changes, providing the context needed to catch bugs a simple diff would miss in your Astro project. ## Key takeaways - Atlas reviews Astro PRs by fetching diffs and reading full files for comprehensive context. - `lsp findReferences` in Atlas catches breaking changes in Astro components that diffs miss. - Atlas integrates `pnpm vitest` and `prettier (prettier-plugin-astro)` for automated Astro quality checks. - Permission-gated tools and unified diffs ensure safe modifications to Astro projects. - Atlas understands Astro's `src/pages` routes and `src/content.config.ts` schemas. - Atlas uses `grep` to find missed updates like old constant names or feature flags in Astro files. ## How Atlas Reviews Astro Pull Requests Atlas streamlines Astro pull request reviews in 2026 by mimicking a careful human, starting with fetching the branch and producing a diff using `bash`. It then moves beyond line-by-line changes to understand the broader impact across `.astro` components and content collections, ensuring a 360-degree view of the proposed changes. Atlas approaches pull request review in Astro projects by first leveraging its `bash` tool to interact with `git`, fetching the relevant branch and generating a raw patch. This initial step provides the foundational diff. However, Atlas quickly moves beyond this raw diff. Instead of relying solely on hunks, the `read` tool pulls the full content of changed files, such as `src/pages/index.astro` or `src/content/blog/post.md`, providing complete surrounding context. For every changed function signature within `.astro` or TypeScript files, the `lsp` tool's `findReferences` operation is executed to identify any callers that the diff might not show, preventing silent breaks. Atlas also uses `grep` to search for patterns that should have been updated but were missed, like old constant names or stale copies in `astro.config.mjs`. Finally, all findings are reported as a `todowrite` list, ordered by severity, guiding the Astro developer through the review process. ## Deep Context for Astro Components and Content Collections Atlas goes beyond simple diffs to provide deep context for Astro projects, reading full files instead of just hunks. This approach ensures that changes in `src/pages` routes or `src/content.config.ts` schemas are understood within their complete `.astro` island or content collection context, preventing 1-line changes from breaking larger structures. Astro's unique architecture, with `.astro` islands, content collections, and a zero-JS-by-default rendering model, demands a review process that understands context beyond isolated lines. Atlas's `read` tool is crucial here; it pulls the entire content of changed files, not just the modified sections. This means if a change is made to a component in `src/components/Card.astro`, Atlas reads the entire `Card.astro` file, allowing it to understand how the change fits into the component's overall structure, its props, and its potential impact on other `.astro` files that import it. Similarly, when reviewing modifications to `src/content.config.ts`, Atlas reads the full schema definition, ensuring that any updates to content collection fields are evaluated in the context of the entire content model, not just the lines that were added or removed. This comprehensive file reading is vital for catching subtle bugs that arise from context-dependent interactions in Astro projects. ## Validating Astro Changes with LSP and Grep To ensure robust Astro pull request reviews, Atlas employs its `lsp` tool to `findReferences` for every changed function signature, catching potential breaks in callers that a diff might not show. This is crucial for Astro's zero-JS-by-default model, where even minor JS changes can have cascading effects across 10s of components. In an Astro project, a seemingly small change to a JavaScript or TypeScript function within an `.astro` component or an integration can have far-reaching consequences. The `lsp` tool within Atlas is specifically designed to address this. For every modified function signature, `lsp findReferences` is executed, scanning the entire codebase to identify all call sites. This is particularly powerful in Astro, where components might implicitly rely on shared utilities or data structures. If a function used across multiple `src/pages` routes or within several `.astro` islands has its signature altered, `lsp findReferences` will flag all affected areas, even if those files were not part of the original diff. Additionally, Atlas's `grep` tool is used to proactively search for specific patterns. This could involve identifying instances of an old constant name that should have been updated, finding stale copies of code, or checking for the correct application of feature flags across the Astro project, including within `astro.config.mjs` or content collection schemas. ## Running Astro Tests and Formatting with Atlas Atlas integrates directly with Astro's toolchain to run tests and format code, ensuring quality and consistency. It executes `pnpm vitest` to validate changes and then applies `pnpm prettier --write .` with `prettier-plugin-astro` to maintain the project's 100% formatting standards. A critical part of any pull request review in an Astro project is validating functionality and maintaining code style. Atlas facilitates this by directly invoking Astro's established toolchain via its `bash` tool. After analyzing the code, Atlas can execute `pnpm vitest` to run all unit and integration tests defined in the project. The results of these tests are then processed and reported back to the developer as a `todowrite` list, ordered by severity, highlighting any regressions or failures. Beyond functionality, code consistency is paramount. Atlas can also trigger `pnpm prettier --write .`, which, when configured with `prettier-plugin-astro`, ensures that all `.astro` files, JavaScript, TypeScript, and other supported files adhere to the project's formatting rules. This automated formatting step, performed before final approval, guarantees that the codebase remains clean and consistent, reducing friction in future development and reviews. ## Atlas's Safety and Approval Workflow for Astro Atlas prioritizes safety in Astro development workflows, implementing a multi-stage approval process. Every Atlas tool call is permission-gated, and it drafts a plan in a read-only agent before switching to a build agent, ensuring 100% transparency and user control over modifications to `astro.config.mjs` or `src/content.config.ts`. The safety of your Astro codebase is a core concern for Atlas. Before any action is taken, every Atlas tool call is permission-gated, allowing you to set `allow`, `ask`, or `deny` rules. This means you retain explicit control over what Atlas can do, whether it's modifying `src/pages` routes or adding a Zod schema to `src/content.config.ts`. The review process itself begins with Atlas drafting a comprehensive plan in a read-only plan agent. This plan, detailing proposed changes and actions, is presented for your review and approval. Only after your explicit consent does Atlas switch to a build agent to execute the plan. For every file edit, Atlas computes a unified diff and surfaces it for your final approval before writing any changes to disk. Furthermore, Atlas snapshots file changes as git patches, providing a robust mechanism for diffing edits and rolling back if necessary, ensuring that your Astro project remains stable and under your complete control throughout the review process. ## Steps 1. Fetch the PR branch and generate the diff using `atlas bash git diff ` to see initial changes in your Astro project. 2. Read the full changed Astro files, like `src/pages/index.astro` or `src/content/blog/post.md`, using `atlas read ` for complete context. 3. For every changed function signature in `.astro` or `.ts` files, run `atlas lsp findReferences ` to check for broken callers across your Astro codebase. 4. Use `atlas grep "old_pattern" src/` to search for specific patterns, such as old constant names or feature flags, across your Astro project. 5. Execute Astro's tests using `atlas bash pnpm vitest` and report findings as a `todowrite` list ordered by severity. 6. Approve the proposed changes, then let Atlas format the Astro codebase with `atlas bash pnpm prettier --write .` using `prettier-plugin-astro`. ## FAQ ### How does Atlas handle Astro's unique file types like `.astro`? Atlas indexes code by AST declarations using tree-sitter, allowing it to understand the structural context of `.astro` islands and content collections, not just blind line windows. ### Can Atlas run `vitest` for my Astro project? Yes, Atlas uses its `bash` tool to execute `pnpm vitest`, integrating directly with your Astro project's test runner and reporting results as a `todowrite` list. ### Does Atlas respect Astro's `prettier` configuration? Absolutely. Atlas can run `pnpm prettier --write .` with `prettier-plugin-astro` via its `bash` tool, ensuring your Astro codebase adheres to your defined formatting standards. ### How does Atlas ensure I approve changes before they are written to my Astro project? Atlas computes a unified diff for every file edit and surfaces it for your approval before writing, and it snapshots file changes as git patches so edits can be diffed and rolled back. ### Can Atlas help me review changes to `src/content.config.ts` schemas in Astro? Yes, Atlas reads your content collection schemas in `src/content.config.ts` and can even add a Zod schema to a content collection, running `astro check` behind a permission prompt. ### What if a change in an Astro component breaks a caller not shown in the diff? Atlas uses its `lsp` tool's `findReferences` operation to check whether a changed signature broke any caller the diff does not show, providing crucial context beyond the immediate changes. ### How does Atlas keep my Astro code private during review? Atlas can build its code index with local Ollama embeddings, keeping your Astro code off third-party servers and ensuring privacy throughout the review process. --- Canonical HTML: https://runatlas.sh/resources/stacks/review-a-pull-request-in-astro Source of truth: aeo_pages row `/resources/stacks/review-a-pull-request-in-astro` (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.