Atlas automates GitHub issue and pull request triage for Fortran developers by integrating directly into GitHub Actions, allowing safe, permission-gated responses, running `fpm test (test-drive)` for validation, and applying `fprettify` for consistent code style before any changes are committed, all within your `fpm.toml` project context.
How to Set Up Atlas for Fortran GitHub Triage
To automate GitHub issue and pull request triage for your Fortran projects, wire the `atlas github` command into a GitHub Actions workflow. This command, available in 2026, requires specific inputs like `MODEL` in `provider/model` form and a `PROMPT` for relevant event types, ensuring Atlas operates within defined parameters.
Integrating Atlas into your Fortran development workflow begins by defining a GitHub Actions YAML file. Within this file, you invoke the `atlas github` command, which is designed to read its inputs directly from the Actions environment. It's crucial to provide the `MODEL` input, specifying the AI model in `provider/model` format, as Atlas will reject runs if this is incorrect. Similarly, for event types that require a response, the `PROMPT` input must be supplied; otherwise, the handler will fail with a `PROMPT input is required for <event> events` message. Atlas is built to understand modern Fortran projects, especially those managed with `fpm` and configured via an `fpm.toml` file. It can read your Fortran modules, explicit interfaces, and intent declarations on every dummy argument, providing a deep understanding of your codebase for accurate triage.
How Atlas Secures Automated Fortran PR and Issue Responses
Atlas ensures secure automation for Fortran GitHub issue and pull request responses by strictly enforcing collaborator permissions. Before any action, Atlas checks if the triggering actor has `admin` or `write` permission, refusing to run for unauthorized users, a critical security measure in 2026 for protecting your Fortran codebase.
Security is paramount when automating responses to Fortran GitHub issues and pull requests. Atlas implements robust checks to prevent unauthorized operations. The `atlas github` handler explicitly verifies the triggering actor's collaborator permission, proceeding only if they possess `admin` or `write` access to the repository. This prevents stray comments or actions from untrusted users from initiating an Atlas run. Furthermore, to avoid accidental triggers, the handler enforces that comments must explicitly mention the configured trigger. Atlas also gracefully handles `ContextOverflowError` by catching it by name and re-throwing it as a user-friendly `prompt-too-large` message, listing the offending Fortran files. This prevents the agent from silently failing or generating incomplete responses due to excessive context, ensuring reliable operation even with large Fortran source files or extensive issue threads.
How Atlas Maintains Fortran Code Quality in GitHub Workflows
Atlas actively maintains Fortran code quality within GitHub workflows by integrating directly with your established toolchain. It can run `fpm test (test-drive)` behind a permission prompt to validate changes and apply `fprettify` over modified sources, ensuring consistent style across your Fortran project in 2026.
Maintaining high code quality in Fortran projects is a core capability of Atlas within a GitHub workflow. After drafting a plan, Atlas can be configured to run `fpm test (test-drive)` to execute your unit tests. This command, familiar to any Fortran developer using `fpm`, allows Atlas to iterate on `gfortran` diagnostics, identifying and suggesting fixes for compilation or runtime issues. Before any proposed changes are finalized, Atlas can also run `fprettify` over the changed Fortran sources. This ensures that all modifications adhere to your project's formatting standards, preventing style inconsistencies. Atlas computes a unified diff for every file edit, including those from `fprettify`, and surfaces it for your approval. This transparent review process allows you to inspect every proposed change to your Fortran code, from legacy `FIXED-form` numerics to modern modules and coarrays, before it is written to disk or committed.
Atlas's Agent-Based Safety for Fortran Code Edits
Atlas employs a multi-stage agent architecture to ensure safety when modifying Fortran code. It first drafts a plan in a read-only plan agent, then asks for permission before switching to a build agent, and every tool call, including `bash` or `edit`, is permission-gated against allow, ask, or deny rules, a robust approach in 2026.
The safety of automated code modifications in Fortran projects is a critical design principle for Atlas. Before any changes are made, Atlas operates with a read-only plan agent, which drafts a comprehensive strategy without executing any commands that could alter your codebase. This plan is then presented for review. Upon approval, Atlas switches to a build agent. Every tool call made by Atlas, whether it's `bash` for executing shell commands, `read` for inspecting files, `grep` for searching Fortran source, or `edit` for modifying code, is permission-gated. These operations are checked against `allow`, `ask`, and `deny` rules, providing granular control over what Atlas can do. Atlas also computes a unified diff for every file edit, presenting it for explicit approval before writing. Furthermore, Atlas snapshots file changes as `git` patches, allowing edits to be easily diffed and rolled back if necessary, providing an additional layer of safety for your Fortran modules, interfaces, and coarrays.
Step by step
- 01Configure `atlas github` in your Fortran project's GitHub Actions workflow.: Create a `.github/workflows/triage.yml` file and define a job that calls `atlas github`, ensuring it runs in an environment where your `fpm.toml` project is accessible.
- 02Set `MODEL` and `PROMPT` inputs for Fortran event types.: Provide the `MODEL` input in `provider/model` format (e.g., `openai/gpt-4o`) and the `PROMPT` input for issue or pull request events that require Atlas to generate a Fortran-specific response.
- 03Ensure the triggering actor has `admin` or `write` permissions for your Fortran repository.: Atlas will automatically check the GitHub actor's permissions and refuse to run if they do not have sufficient access to modify your Fortran codebase.
- 04Require a mention in comments to trigger Atlas for Fortran triage.: Configure the workflow to enforce that comments must explicitly mention the configured trigger (e.g., `@atlas triage`) to initiate an Atlas run, preventing accidental Fortran code changes.
- 05Allow Atlas to read your Fortran project's `fpm.toml` and source files.: Atlas will index your Fortran modules, explicit interfaces, and intent declarations, using `tree-sitter` for AST declarations, providing a deep understanding of your `FIXED-form` or modern Fortran code.
- 06Review Atlas's read-only plan for Fortran code modifications.: Atlas will draft a plan in a read-only agent, outlining proposed changes to your Fortran files, such as moving a common block into a module or adding `test-drive` unit tests under `test/`.
- 07Approve Atlas to run `fpm test (test-drive)` and `fprettify` on Fortran changes.: Behind a permission prompt, Atlas can execute `fpm test (test-drive)` to validate changes and run `fprettify` over modified Fortran sources to ensure consistent formatting.
- 08Approve Atlas's unified diff for Fortran code edits.: Atlas will present a unified diff for every proposed Fortran file edit, allowing you to review and approve changes before they are written to disk or staged for a `git` commit.
Frequently asked questions
- How does Atlas ensure safety when triaging Fortran GitHub issues?
- Atlas ensures safety by checking the triggering actor's `admin` or `write` permissions, requiring explicit mentions to trigger, operating with a read-only plan agent, and gating every tool call (like `bash` or `edit`) against `allow`, `ask`, or `deny` rules before modifying Fortran code.
- Can Atlas run `fpm test` on my Fortran project in a GitHub workflow?
- Yes, Atlas can run `fpm test (test-drive)` behind a permission prompt within your GitHub workflow. It can iterate on `gfortran` diagnostics and use the results to refine proposed changes to your Fortran codebase.
- What Fortran formatting tool does Atlas use in GitHub Actions?
- Atlas uses `fprettify` to format Fortran sources within GitHub Actions. It can run `fprettify` over changed files and present the resulting unified diff for your approval, ensuring consistent style for your Fortran modules and interfaces.
- How do I configure Atlas to respond only to trusted users in my Fortran repository?
- Configure your GitHub workflow to use `atlas github`, which automatically checks the triggering actor's collaborator permission. Atlas will only proceed if the user has `admin` or `write` access to your Fortran repository, ensuring only trusted users can initiate automated responses.
- Does Atlas handle large Fortran codebases without context overflow?
- Yes, Atlas explicitly handles context overflow. It catches `ContextOverflowError` by name and re-throws it as a `prompt-too-large` message, listing the offending Fortran files, preventing silent failures and ensuring you're aware of any context limitations.
- How does Atlas integrate with `fpm.toml` for Fortran projects?
- Atlas is designed to run in projects with an `fpm.toml` file. It builds its code index by parsing your Fortran modules, explicit interfaces, and intent declarations, leveraging the structure defined by `fpm` to understand your codebase deeply.
- Can Atlas stage and commit Fortran code changes on my behalf?
- Yes, Atlas can read `git` branches, status, and diffs, and can stage and create commits on your behalf for Fortran code changes. All proposed edits are presented as unified diffs for your approval, and file changes are snapshotted as `git` patches for rollback.
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 Fortran: fpm.toml, Explicit Interfaces, and fprettify in 2026
Atlas is a terminal-native AI coding agent for Fortran in 2026. It reads modules, explicit interfaces, and intent declarations, runs fpm test behind a prompt, and runs fprettify.
Plan a Multi-File Change in Fortran with Atlas Before Editing in 2026
Design and review complex Fortran code changes across multiple files using Atlas in 2026. Plan safely with fpm, fprettify, and gfortran integration before modifying a single line.
Refactor a Legacy Fortran Module with Atlas in 2026
Modernize Fortran code in 2026. Use Atlas to refactor legacy modules, move COMMON blocks, and ensure no regressions with fpm test and fprettify.
Run Atlas Headless in CI for Fortran in 2026
Fortran developers in 2026 can run Atlas headless in CI pipelines to automate tasks, integrate with fpm, and get machine-readable output for robust automation.
Rename a symbol across the repo in Fortran with Atlas in 2026
Refactor Fortran code with Atlas in 2026. Rename functions, classes, or constants across your entire repository using fpm, fprettify, and precise AST-based tools.
Diagnose a Hanging or Long-Running Fortran Command with Atlas in 2026
Fortran developers in 2026 can use Atlas to diagnose hanging or slow fpm builds and scripts. Identify if commands are blocked on input or genuinely slow, and get them unstuck efficiently.
Locate where a behavior is implemented in Fortran with Atlas in 2026
Fortran developers in 2026 can use Atlas to pinpoint exact code implementations. Leverage semantic search, grep, and LSP tools to navigate modules, interfaces, and fpm projects, ensuring precise code discovery and