To run an Atlas session non-interactively in a SolidJS CI pipeline and get machine-readable output, invoke `atlas run` with the `--format json` flag. This allows your pipeline to parse events, integrate with `pnpm` for dependencies, and ensure code quality with `prettier` and `vitest (@solidjs/testing-library)` for testing, all within your existing SolidJS workflow in 2026.
How to Invoke Atlas Headless in a SolidJS CI Pipeline
Running Atlas headless in a SolidJS CI pipeline in 2026 is straightforward: use `atlas run` with your prompt. This command operates non-interactively by default, sending a single prompt and exiting when the session becomes idle, making it ideal for automated workflows that need to process 1 job at a time.
To execute Atlas non-interactively within a SolidJS CI pipeline, use the `atlas run` command. This command's default mode is designed for automation: it accepts a single prompt as an argument, streams all session events to standard output, and then gracefully exits once the session becomes idle. For pipeline steps that require structured data rather than human-readable prose, append the `--format json` flag. This ensures that subsequent automated steps can reliably parse Atlas's actions, tool calls, and proposed changes to your SolidJS codebase. When setting up your CI environment, ensure `pnpm` is available for Atlas to interact with your project's dependencies and scripts, mirroring a typical SolidJS development setup.
Pre-Approving Tools for Headless SolidJS Code Changes
For Atlas to modify SolidJS code in a headless CI environment, pre-approving necessary tools is critical, as there's no user to answer 'ask' prompts. Atlas requires explicit permission for tools like `bash`, `read`, `edit`, and `todowrite` to interact with your `.tsx` files and `vite.config.ts` configuration, ensuring secure operations in 2026.
In a headless CI run, Atlas operates without human intervention, meaning it cannot prompt for approval when attempting to use a tool. To enable Atlas to perform tasks such as fixing SolidJS reactivity bugs or adding tests, you must pre-approve the required tools through its permission configuration. This involves setting `allow` rules for tools like `bash` (for running `pnpm` commands), `read` (for analyzing SolidJS files and the `createSignal` graph), `edit` (for modifying `.tsx` files), and `todowrite` (for creating new files or updating existing ones). This explicit configuration ensures that Atlas can securely and autonomously interact with your SolidJS project's files and execute commands like `pnpm vitest` or `pnpm prettier` within the CI pipeline.
Integrating Atlas with SolidJS Testing and Formatting in CI
Atlas integrates directly with SolidJS's testing and formatting tools, `vitest (@solidjs/testing-library)` and `prettier`, within a CI pipeline. After Atlas proposes a fix for a common SolidJS reactivity bug, such as a destructured prop issue, it can add tests and format touched `.tsx` files, ensuring code quality before a merge in 2026.
Atlas is designed to understand and interact with the SolidJS ecosystem, including its testing and formatting conventions. When Atlas identifies a common SolidJS reactivity bug, such as a destructured prop that breaks reactivity, it can draft a plan to fix it. Following this, Atlas can leverage the `vitest (@solidjs/testing-library)` framework to add new tests or modify existing ones to validate its changes. After applying code edits to `.tsx` files, Atlas can then invoke `prettier` to automatically format the touched files, ensuring adherence to your project's coding standards. All these actions are permission-gated, requiring pre-approval in a headless CI environment, allowing for automated code quality checks and improvements within your SolidJS workflow.
Resuming and Forking Atlas Sessions for SolidJS Development
Iterative development or debugging in a SolidJS CI pipeline can leverage Atlas's session management capabilities, allowing you to resume or fork prior runs. Commands like `--continue`, `--session`, or `--fork` enable a pipeline step to build upon an earlier Atlas session, which is particularly useful for complex SolidJS refactors that might span multiple CI jobs in 2026.
For complex SolidJS development tasks that might require multiple CI runs or debugging, Atlas provides robust session management. The `--continue` flag allows a new `atlas run` command to pick up exactly where a previous session left off, preserving context and progress. Alternatively, `--session <session-id>` lets you specify a particular session to resume, which is useful for replaying or inspecting specific runs. The `--fork` option creates a new session based on an existing one, allowing for experimentation without altering the original. These capabilities are invaluable in a SolidJS CI pipeline for handling long-running refactors, debugging intermittent issues, or iterating on AI-generated code, as Atlas snapshots file changes as git patches, enabling easy diffing and rollback.
Parsing Machine-Readable Output from Headless Atlas in SolidJS CI
When running Atlas headless in a SolidJS CI pipeline, the `--format json` flag provides a raw event stream, crucial for machine-readable output. This structured data allows subsequent pipeline steps to programmatically parse Atlas's actions, diffs, and tool calls, enabling automated checks and reporting on code changes to `.tsx` files in 2026.
The `--format json` flag is essential for integrating Atlas into automated SolidJS CI workflows that require programmatic interaction with its output. Instead of human-readable prose, Atlas streams a raw sequence of JSON events to stdout, detailing every step of its session. This includes the agent's plan, tool calls (e.g., `bash` executing `pnpm vitest`), file `read` operations, `edit` proposals for `.tsx` files, and the unified diffs generated for every change. A subsequent pipeline step can parse this JSON stream to extract specific information, such as the proposed code changes, the outcome of tests, or the status of formatting, enabling automated approval, rejection, or further processing of Atlas's contributions to your SolidJS project.
Step by step
- 01Configure Atlas for SolidJS Project Indexing: Ensure your SolidJS project includes `vite.config.ts` with `vite-plugin-solid` so Atlas can correctly index `createSignal`, `createMemo`, and `createEffect` graphs.
- 02Set Headless Tool Permissions for SolidJS: Pre-approve Atlas tools like `bash`, `read`, `edit`, and `todowrite` in your Atlas configuration to allow modifications to `.tsx` files and execution of `pnpm` commands without interactive prompts.
- 03Execute Atlas Headless with a SolidJS-Specific Prompt: Invoke `atlas run --format json --command "fix the destructured prop reactivity issue in src/components/MyComponent.tsx" --model github/gpt-4-turbo` to address a common SolidJS bug.
- 04Process Machine-Readable Atlas Output: Capture the JSON event stream from `stdout` to programmatically parse Atlas's proposed changes, tool calls, and unified diffs for `.tsx` files.
- 05Automate SolidJS Test Execution with Atlas: After Atlas proposes code edits, configure your CI to trigger `pnpm vitest` using `@solidjs/testing-library` to validate the changes.
- 06Apply SolidJS Code Formatting: Instruct Atlas to run `pnpm prettier --write src/components/MyComponent.tsx` on any modified SolidJS files to maintain consistent code style.
- 07Review and Stage Atlas-Generated SolidJS Changes: Examine the unified diffs for `.tsx` files generated by Atlas, then use Atlas's `git` capabilities to stage and commit approved changes.
Frequently asked questions
- How do I run Atlas non-interactively in a SolidJS CI pipeline?
- Use `atlas run` with the `--format json` flag in your CI script. This executes a single prompt and streams machine-readable events, exiting when idle, perfect for SolidJS automation.
- What SolidJS tools does Atlas integrate with in CI?
- Atlas integrates with `pnpm` for package management, `vitest (@solidjs/testing-library)` for testing, and `prettier` for code formatting, all within your SolidJS project's CI workflow.
- How does Atlas handle permissions for modifying SolidJS code in CI?
- You must pre-approve tools like `bash`, `read`, `edit`, and `todowrite` in Atlas's permission configuration, as headless runs cannot prompt for approval when interacting with SolidJS files.
- Can Atlas fix SolidJS reactivity issues in CI?
- Yes, Atlas can identify and fix common SolidJS reactivity bugs, such as those caused by destructured props, by analyzing your `createSignal`, `createMemo`, and `createEffect` graph.
- How can I get machine-readable output from Atlas in a SolidJS CI job?
- Pass the `--format json` flag to `atlas run`. This streams raw event data to stdout, which your SolidJS CI pipeline can parse for automated processing and reporting on `.tsx` file changes.
- How does Atlas ensure code quality for SolidJS changes in CI?
- Atlas can add tests using `@solidjs/testing-library` and run `vitest`, then apply `prettier` formatting to touched `.tsx` files, all behind permission prompts, maintaining SolidJS code standards.
- Can I resume an Atlas session in a SolidJS CI pipeline?
- Yes, use `atlas run --continue` or `atlas run --session <session-id>` to resume a previous Atlas session, allowing iterative development or debugging of SolidJS code in CI.
Try Atlas in your terminal
The terminal-native AI coding agent. Free core, single binary.
Install AtlasRelated guides
Run Atlas Headless in CI with Atlas (2026 Workflow)
How to run Atlas headless in CI in 2026: atlas run sends one prompt and exits when the session goes idle, with --format json, --command, and --continue for pipeline steps.
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.
Automate GitHub Issue and Pull Request Triage in SolidJS with Atlas in 2026
Streamline GitHub issue and pull request triage in your SolidJS projects using Atlas. Configure workflows to safely automate responses, enforce trusted user permissions, and integrate with your `pnpm` and `vitest`
Debug a single failing test in SolidJS with Atlas in 2026
Pinpoint and fix a single failing SolidJS test using Atlas. Leverage `vitest (@solidjs/testing-library)` and `pnpm` to efficiently debug reactivity issues in your SolidJS applications.
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.
Rename a symbol across the repo in SolidJS with Atlas in 2026
In 2026, rename functions, classes, or constants across your SolidJS codebase with Atlas. Leverage lsp, grep, and edit for precise, verified refactoring.
Extract a Shared Helper from Duplicated Code in SolidJS with Atlas in 2026
Refactor your SolidJS codebase in 2026 by extracting duplicated logic into a shared helper using Atlas. Leverage pnpm, vitest (@solidjs/testing-library), and prettier for a streamlined workflow.
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.