In 2026, SolidJS developers can automate GitHub issue and pull request triage with Atlas, the terminal-native AI coding agent, by wiring the `atlas github` command into their workflows. This integration ensures that Atlas responds safely and only for trusted users, leveraging the familiar `pnpm` package manager, `vitest (@solidjs/testing-library)` for testing, and `prettier` for code formatting within SolidJS projects.
How to set up Atlas for GitHub triage in a SolidJS project
Setting up Atlas for GitHub triage in a SolidJS project involves a few key steps, ensuring your `vite.config.ts` is correctly configured with `vite-plugin-solid` by 2026. Atlas builds its code index using AST declarations via tree-sitter, not blind line windows, providing precise context for your SolidJS codebase.
To enable Atlas to effectively triage GitHub issues and pull requests within a SolidJS project, you first need to ensure Atlas can understand your codebase. Atlas indexes code by AST declarations using tree-sitter, which is crucial for SolidJS's reactivity model where a component body runs exactly once. This allows Atlas to read your `createSignal`, `createMemo`, and `createEffect` graph, as well as any SolidStart routes. For instance, Atlas can identify and fix a destructured prop that broke reactivity, a common SolidJS bug. The `atlas github` command is the entry point for this automation, requiring a `MODEL` in `provider/model` form and a `PROMPT` for specific event types. Atlas can build its code index with local Ollama embeddings, keeping your SolidJS code off third-party servers, which is a significant security advantage.
Configuring GitHub Workflows for SolidJS Triage with Atlas
Configuring GitHub workflows for SolidJS triage with Atlas requires precise input settings and permission checks, ensuring that by 2026, only trusted actions are performed. The `atlas github` command is designed to refuse to run if its inputs, such as the `MODEL` or `PROMPT`, are incorrect, providing a robust first line of defense.
To integrate Atlas into your SolidJS project's GitHub workflow, you must wire the `atlas github` command into a `.github/workflows/*.yml` file. This command expects specific inputs: a `MODEL` in `provider/model` format (e.g., `ollama/llama3`) and a `PROMPT` for the event types that require one. If the `PROMPT` input is missing for a required event, the handler fails with a clear 'PROMPT input is required for <event> events.' message. For example, a workflow might look like this: ```yaml name: SolidJS Triage with Atlas on: issues: types: [opened, reopened] pull_request_target: types: [opened, reopened] jobs: triage: runs-on: ubuntu-latest steps: - uses: actions/checkout@v4 - name: Run Atlas Triage run: atlas github env: MODEL: "ollama/llama3" PROMPT: "Review this SolidJS issue and suggest a fix." GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} ``` Atlas also enforces that comments must mention the configured trigger to start a run, preventing stray comments from initiating actions.
Ensuring Safety and Trusted User Access for Atlas in SolidJS Workflows
Ensuring safety and trusted user access for Atlas in SolidJS workflows is paramount, with Atlas performing 2 critical permission checks before any action is taken. Atlas refuses to run if the triggering actor lacks admin or write permission, providing a strong security boundary for your SolidJS codebase.
Atlas prioritizes safety and trust in automated workflows. Before executing any triage actions on your SolidJS project, Atlas performs two crucial checks. First, it verifies that the triggering actor has either `admin` or `write` collaborator permission on the repository. If this check fails, Atlas refuses to run, preventing unauthorized access. Second, to avoid accidental runs, the `atlas github` handler enforces that comments must explicitly mention the configured trigger (e.g., `@atlas triage`) to initiate a workflow. Every Atlas tool call, including `bash`, `read`, `grep`, and `edit`, is permission-gated against `allow`, `ask`, and `deny` rules before it runs. This granular control ensures that Atlas only performs actions explicitly permitted within your SolidJS development environment. Atlas also drafts a plan in a read-only plan agent and asks for approval before switching to a build agent, providing an additional layer of human oversight.
Atlas's Interaction with SolidJS Codebase and Toolchain
Atlas interacts deeply with the SolidJS codebase and its toolchain, understanding the unique reactivity model where a component body runs exactly once, a key SolidJS idiom by 2026. Atlas can add tests with `@solidjs/testing-library` and run `vitest` behind a permission prompt, integrating directly with your existing setup.
Atlas is designed to be deeply integrated with the SolidJS development environment. It understands SolidJS-specific constructs like `createSignal`, `createMemo`, and `createEffect`, allowing it to analyze and modify your reactivity graph. When Atlas proposes changes, such as fixing a destructured prop that broke reactivity, it can also add tests using `@solidjs/testing-library`. These tests are then run with `vitest` via the actual command `pnpm vitest`, but only after a permission prompt, ensuring developer oversight. After making edits, Atlas can run `prettier` on the touched `.tsx` files with `pnpm prettier --write .` to maintain code style consistency. Atlas searches code with hybrid semantic and keyword retrieval fused by reciprocal rank fusion, ensuring it finds relevant SolidJS code efficiently. It also reads `git` branches, status, and diffs, and can stage and create commits on your behalf, making it a comprehensive tool for SolidJS development.
Handling Context Overflow and Reviewing Atlas's SolidJS Edits
Handling context overflow explicitly is a critical safety feature when Atlas processes SolidJS code, as a `ContextOverflowError` is caught by name and re-thrown as a prompt-too-large message listing the offending files. This ensures that by 2026, you always know why Atlas couldn't process a large SolidJS file or pull request.
When Atlas processes large SolidJS issues or pull requests, it explicitly handles context overflow. A `ContextOverflowError` is caught by name and re-thrown as a user-friendly 'prompt-too-large' message, which lists the specific SolidJS files that caused the overflow. This prevents silent failures and guides developers on how to address the issue, perhaps by narrowing the scope of the prompt. For any proposed changes to your SolidJS codebase, Atlas computes a unified diff for every file edit and surfaces it for approval before writing. This allows you to review changes to your `.tsx` files, `vite.config.ts`, or `pnpm-lock.yaml` before they are committed. Atlas also snapshots file changes as `git` patches, so edits can be diffed and rolled back if necessary, providing a robust safety net for your SolidJS project.
Step by step
- 01Configure `vite.config.ts` for Atlas: Ensure your SolidJS project's `vite.config.ts` uses `vite-plugin-solid` so Atlas can correctly index your `createSignal`, `createMemo`, and `createEffect` graph.
- 02Create GitHub Workflow: Add a `.github/workflows/atlas-triage.yml` file to your SolidJS repository, wiring the `atlas github` command to trigger on `issues` or `pull_request_target` events.
- 03Set Atlas Inputs: Define the `MODEL` environment variable (e.g., `ollama/llama3`) and provide a `PROMPT` input for the specific event types Atlas should handle in your SolidJS workflow.
- 04Enforce Permissions: Ensure the workflow is configured to run only when the triggering actor has `admin` or `write` permissions, and that comments explicitly mention the configured trigger (e.g., `@atlas triage`).
- 05Review Atlas Plan: When Atlas proposes changes to your SolidJS codebase, review the read-only plan agent's draft and approve before it switches to the build agent.
- 06Approve SolidJS Code Edits: Examine the unified diff for any proposed edits to your `.tsx` files or other SolidJS-related configurations, and approve them before Atlas writes the changes.
- 07Run SolidJS Tests: If Atlas adds tests with `@solidjs/testing-library`, confirm that `pnpm vitest` runs successfully behind the permission prompt.
- 08Format SolidJS Files: After edits, ensure Atlas runs `pnpm prettier --write .` on the touched SolidJS `.tsx` files to maintain consistent formatting.
Frequently asked questions
- How does Atlas understand SolidJS's reactivity model?
- Atlas indexes SolidJS code by AST declarations using tree-sitter, allowing it to read your `createSignal`, `createMemo`, and `createEffect` graph, understanding that a component body runs exactly once.
- What SolidJS-specific tools does Atlas use for code quality?
- Atlas integrates with the SolidJS toolchain, using `pnpm` as the package manager, `vitest (@solidjs/testing-library)` for running tests, and `prettier` for formatting `.tsx` files.
- How does Atlas ensure only trusted users can trigger GitHub triage in SolidJS?
- Atlas checks that the triggering actor has `admin` or `write` collaborator permission and enforces that comments must mention the configured trigger before running any SolidJS triage workflow.
- Can Atlas fix common SolidJS bugs like destructured prop reactivity issues?
- Yes, Atlas can identify and fix common SolidJS bugs, such as a destructured prop that broke reactivity, which is a frequent issue in SolidJS development.
- How do I review changes Atlas proposes for my SolidJS project?
- Atlas drafts a plan in a read-only agent and computes a unified diff for every file edit, surfacing it for your approval before writing any changes to your SolidJS `.tsx` files.
- What happens if a SolidJS pull request is too large for Atlas to process?
- Atlas explicitly catches `ContextOverflowError` and re-throws it as a 'prompt-too-large' message, listing the specific SolidJS files that caused the context overflow.
- Does Atlas keep my SolidJS code private when indexing?
- Yes, Atlas can build its code index with local Ollama embeddings, ensuring your SolidJS code remains on your local machine and off third-party servers.
Try Atlas in your terminal
The terminal-native AI coding agent. Free core, single binary.
Install AtlasRelated guides
Automate GitHub Issue and Pull Request Triage with Atlas (2026 Workflow)
How to automate GitHub issue and pull request triage with Atlas in 2026: the atlas github command checks the actor has admin or write permission before it does anything.
Atlas for SolidJS: A Terminal-Native AI Coding Agent Built on Solid, for Solid, in 2026
Atlas is a terminal-native AI coding agent for SolidJS in 2026. It reads your createSignal and createMemo graph, fixes destructured props that break reactivity, and runs vitest.
Locate where a behavior is implemented in SolidJS with Atlas in 2026
In 2026, SolidJS developers use Atlas to pinpoint exact file and symbol implementations. Leverage semantic search, grep, and LSP for `createSignal` and component behaviors.
Run the test suite and triage failures in SolidJS with Atlas in 2026
Streamline SolidJS test failure triage in 2026 with Atlas. Quickly turn `vitest` output into a prioritized list of distinct root causes, leveraging `pnpm` and `prettier` for efficient debugging and fixes.
Document a SolidJS Module with a README in 2026 using Atlas
In 2026, Atlas helps SolidJS developers generate accurate READMEs for modules by analyzing live code, ensuring documentation reflects current implementation, not outdated plans. It integrates with your existing SolidJS
Refactor a Legacy SolidJS Module with Atlas in 2026
Streamline your SolidJS codebase in 2026 by refactoring legacy modules with Atlas. Maintain behavior, prevent breaking changes, and leverage your existing pnpm, vitest, and prettier toolchain.
Diagnose a hanging or long-running command in SolidJS with Atlas in 2026
Pinpoint why your SolidJS builds or scripts are stuck or slow in 2026. Atlas, the terminal-native AI agent, uses its bash tool to diagnose interactive input blocks or genuine performance bottlenecks in your pnpm
Upgrade a Dependency and Fix Breakage in SolidJS with Atlas in 2026
SolidJS developers in 2026 can use Atlas to efficiently upgrade major dependencies, automatically fixing compile and test failures. Atlas integrates with pnpm, vitest, and prettier to streamline your workflow.