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.
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.
Step by step
- 01Fetch the PR branch and generate the diff using `atlas bash git diff <branch>` to see initial changes in your Astro project.
- 02Read the full changed Astro files, like `src/pages/index.astro` or `src/content/blog/post.md`, using `atlas read <file_path>` for complete context.
- 03For every changed function signature in `.astro` or `.ts` files, run `atlas lsp findReferences <symbol>` to check for broken callers across your Astro codebase.
- 04Use `atlas grep "old_pattern" src/` to search for specific patterns, such as old constant names or feature flags, across your Astro project.
- 05Execute Astro's tests using `atlas bash pnpm vitest` and report findings as a `todowrite` list ordered by severity.
- 06Approve the proposed changes, then let Atlas format the Astro codebase with `atlas bash pnpm prettier --write .` using `prettier-plugin-astro`.
Frequently asked questions
- 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.
Try Atlas in your terminal
The terminal-native AI coding agent. Free core, single binary.
Install AtlasRelated guides
Review a Pull Request with Atlas (2026 Workflow)
How to review a pull request with Atlas in 2026: bash produces the raw patch, read pulls whole files, the lsp tool's findReferences checks callers the diff never shows.
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.
Automate GitHub Issue and Pull Request Triage in Astro with Atlas for 2026
Automate GitHub issue and pull request triage in your Astro projects with Atlas in 2026. Safely manage contributions, enforce trusted user access, and streamline workflows using `pnpm` and `vitest`.
Self-review your working diff before committing in Astro with Atlas in 2026
Catch your own mistakes in Astro projects before they reach review or CI. Atlas helps Astro developers in 2026 self-review uncommitted diffs, run `vitest` tests, and format code with `prettier (prettier-plugin-astro)`
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.
Audit an Astro Repository with Parallel Subagents in Atlas in 2026
Sweep an entire Astro repository for problems without exceeding your main session's context window using Atlas's parallel subagents. Leverage `pnpm`, `vitest`, and `prettier` for efficient, focused audits.
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
Add a Regression Test for an Astro Bug Fix with Atlas in 2026
Lock in Astro bug fixes with Atlas by adding regression tests that fail before and pass after. Use vitest, pnpm, and prettier to ensure robust, maintainable Astro code in 2026.