How does Atlas ensure it finds *all* PowerShell API calls, even dynamic ones?

Atlas combines `lsp findReferences` for static analysis of `.psm1` and `.psd1` files with `grep` for dynamic or string-based usages. This hybrid approach ensures no PowerShell callsite, whether explicit or dynamically constructed, is missed during the enumeration phase.

What happens if my PowerShell script changes while Atlas is migrating an API?

Atlas's `apply_patch` tool is context-anchored. If the expected `old_lines` or surrounding context in your PowerShell script has drifted due to concurrent changes, `apply_patch` will throw 'Failed to find expected lines' rather than misapplying the patch, ensuring the integrity of your codebase.

Can Atlas run my `Pester` tests automatically after a PowerShell API migration?

Yes, Atlas uses its `bash` tool to execute `Invoke-Pester` after each file modification. It only marks the `todowrite` entry for that callsite as complete once the `Pester` tests pass, providing immediate feedback and ensuring functional integrity for your PowerShell scripts.

How does Atlas help maintain PowerShell code style during a migration?

Atlas can be configured to run `PSScriptAnalyzer Invoke-Formatter` over the unified diff of its changes. This ensures that all modifications adhere to your team's PowerShell formatting standards and clears any `PSScriptAnalyzer` warnings, maintaining code quality throughout the migration process.

Does Atlas keep my PowerShell code local when using AI for migrations?

Yes, Atlas can build its code index using local Ollama embeddings. This capability ensures that your PowerShell codebase remains within your local environment, keeping your intellectual property off third-party servers and enhancing data privacy during AI-assisted migrations.

Can Atlas help me add `CmdletBinding` to my PowerShell functions?

Yes, Atlas can be asked to add `CmdletBinding` and `SupportsShouldProcess` to destructive PowerShell functions. This ensures that your cmdlets properly honor `-WhatIf` and `-Confirm` parameters, aligning with best practices for robust PowerShell module development in 2026.

Migrate a deprecated API across every callsite in PowerShell with Atlas in 2026

Migrating a deprecated PowerShell API across an entire codebase without missing a single callsite is a critical, often error-prone task, but Atlas streamlines this process in 2026 by integrating directly with your PowerShell toolchain. Atlas leverages lsp for comprehensive caller enumeration, todowrite for tracking progress, and apply_patch for safe, context-aware modifications, all while validating changes with Invoke-Pester and formatting with PSScriptAnalyzer Invoke-Formatter to maintain code quality.

How Atlas finds all PowerShell API calls for migration

Atlas ensures a complete enumeration of deprecated PowerShell API calls in 2026 by combining static and dynamic analysis. It uses the lsp tool's findReferences operation to identify all declared usages within your .psm1 module and .psd1 manifest files, then cross-checks with grep for any 100% string-based or dynamically invoked calls.

To begin a migration, Atlas first builds a comprehensive index of your PowerShell codebase using AST declarations via tree-sitter, not blind line windows. This allows the lsp tool to accurately pinpoint every reference to a deprecated function, cmdlet, or module. For instance, if you are deprecating a function named `Get-OldData`, Atlas will query the language server to find all explicit calls. Recognizing that PowerShell can involve dynamic execution or string-based invocations, Atlas then employs its grep tool to scan for any remaining textual occurrences of `Get-OldData` that might have been missed by static analysis. This dual-pronged approach guarantees that every single callsite, whether explicit in a `.ps1` script or dynamically constructed, is identified before any migration work begins, preventing half-measures.

Tracking PowerShell API migration progress with Atlas

Tracking the migration of a deprecated PowerShell API across potentially hundreds of callsites is made transparent and manageable in 2026 with Atlas's todowrite tool. Atlas creates one distinct todowrite entry for each identified callsite, ensuring that partial progress is always visible and no single migration task is silently skipped or forgotten.

Once Atlas has enumerated all calls to the deprecated PowerShell API, it systematically converts each identified callsite into a trackable work item using the todowrite tool. This granular approach means that if your codebase has 50 instances of a deprecated function, you will have 50 individual todowrite entries. As Atlas processes each file and successfully migrates a callsite, the corresponding todowrite entry is updated. This provides a clear, real-time overview of the migration's status, allowing you to see exactly how many callsites remain and ensuring that the entire codebase is systematically addressed without any omissions. This visibility is crucial for large-scale refactoring efforts in complex PowerShell environments.

Safely applying PowerShell API migration changes with Atlas

Atlas applies changes for deprecated PowerShell API migrations with robust safety mechanisms in 2026, primarily through its apply_patch tool. This tool performs context-anchored patching, meaning it explicitly seeks the hunk's context and old_lines. If the target file has drifted or the expected lines are not found, apply_patch will throw a 'Failed to find expected lines' error rather than misapplying the change, ensuring code integrity.

When it's time to modify a PowerShell script, Atlas uses apply_patch to perform the actual migration. This tool is designed for precision and safety. Instead of blindly inserting code, apply_patch generates a patch that includes not only the old and new lines but also surrounding context. Before applying, it verifies that the expected `old_lines` and their context are present in the target `.ps1` file. If, for example, another developer has modified the file in the interim, causing the context to shift, apply_patch will fail explicitly. This prevents erroneous or partial migrations that could introduce subtle bugs. Furthermore, Atlas computes a unified diff for every file edit and surfaces it for your approval before writing, and can snapshot file changes as git patches, allowing for easy diffing and rollback if needed.

Verifying PowerShell API migrations with Pester and PSScriptAnalyzer

Atlas integrates directly with the PowerShell toolchain to verify API migrations, running `Invoke-Pester` after each file modification in 2026. It uses its bash tool to execute your `.Tests.ps1` files, and only marks a todowrite entry as complete once the associated Pester tests pass, ensuring functional correctness and preventing regressions.

After Atlas modifies a PowerShell script to migrate a deprecated API, it immediately triggers a validation step. Using its bash tool, Atlas executes `Invoke-Pester` against the affected `.Tests.ps1` files. This ensures that the changes haven't introduced any regressions or broken existing functionality. If the `Pester` tests fail, Atlas will not mark the corresponding todowrite entry as complete, signaling that further attention is required. This tight feedback loop is critical for maintaining the reliability of your PowerShell automation. Additionally, Atlas can be configured to run `PSScriptAnalyzer Invoke-Formatter` over the unified diff of its changes, ensuring that the migrated code adheres to your team's style guidelines and clears any `PSScriptAnalyzer` warnings before committing.

Finalizing and cleaning up deprecated PowerShell APIs with Atlas

The final stage of a deprecated PowerShell API migration in 2026 involves a thorough cleanup and verification, which Atlas automates. After all callsites are migrated, Atlas performs a final grep for the deprecated symbol, confirming zero remaining hits. This ensures the old implementation can be safely deleted, completing the migration with 100% confidence.

Once all individual callsites have been migrated and their respective `Pester` tests have passed, Atlas performs a crucial final verification step. It uses its grep tool to scan the entire codebase one last time for any lingering references to the deprecated PowerShell symbol. This final check acts as a safeguard, catching any obscure or previously missed dynamic usages. Only when this grep confirms zero remaining hits is the migration considered complete. At this point, Atlas can assist in deleting the old, deprecated function or module implementation from your `.psm1` file. Atlas also reads git branches, status, and diffs, and can stage and create commits on your behalf, streamlining the entire process from initial enumeration to final commit.

Step by step

01Run Atlas in your PowerShell module directory, ensuring it can read your `.psm1` module and `.psd1` manifest.
02Enumerate all calls to the deprecated PowerShell symbol using `atlas lsp findReferences` and cross-check with `atlas grep` for dynamic usages.
03Create a `todowrite` entry for each identified PowerShell callsite to track individual migration tasks.
04For each callsite, use `atlas apply_patch` to implement the replacement PowerShell API, leveraging its context-anchored safety.
05After each file modification, execute `Invoke-Pester` via `atlas bash` to validate the changes against your `.Tests.ps1` files.
06Mark the `todowrite` entry as complete only after the `Invoke-Pester` tests pass successfully for that file.
07Once all calls are migrated, run `atlas grep` one final time to confirm zero remaining usages of the deprecated PowerShell symbol.
08Delete the old deprecated PowerShell function or module implementation from your codebase.
09Have Atlas clear `PSScriptAnalyzer` warnings and run `PSScriptAnalyzer Invoke-Formatter` over the diff, then stage and commit the changes.

Frequently asked questions

How does Atlas ensure it finds *all* PowerShell API calls, even dynamic ones?: Atlas combines `lsp findReferences` for static analysis of `.psm1` and `.psd1` files with `grep` for dynamic or string-based usages. This hybrid approach ensures no PowerShell callsite, whether explicit or dynamically constructed, is missed during the enumeration phase.
What happens if my PowerShell script changes while Atlas is migrating an API?: Atlas's `apply_patch` tool is context-anchored. If the expected `old_lines` or surrounding context in your PowerShell script has drifted due to concurrent changes, `apply_patch` will throw 'Failed to find expected lines' rather than misapplying the patch, ensuring the integrity of your codebase.
Can Atlas run my `Pester` tests automatically after a PowerShell API migration?: Yes, Atlas uses its `bash` tool to execute `Invoke-Pester` after each file modification. It only marks the `todowrite` entry for that callsite as complete once the `Pester` tests pass, providing immediate feedback and ensuring functional integrity for your PowerShell scripts.
How does Atlas help maintain PowerShell code style during a migration?: Atlas can be configured to run `PSScriptAnalyzer Invoke-Formatter` over the unified diff of its changes. This ensures that all modifications adhere to your team's PowerShell formatting standards and clears any `PSScriptAnalyzer` warnings, maintaining code quality throughout the migration process.
Does Atlas keep my PowerShell code local when using AI for migrations?: Yes, Atlas can build its code index using local Ollama embeddings. This capability ensures that your PowerShell codebase remains within your local environment, keeping your intellectual property off third-party servers and enhancing data privacy during AI-assisted migrations.
How does Atlas handle reviewing and approving changes to my PowerShell scripts?: Atlas drafts a plan in a read-only plan agent and asks for approval before switching to a build agent. It computes a unified diff for every file edit and surfaces it for your approval before writing, and can snapshot changes as git patches for easy diffing and rollback.
Can Atlas help me add `CmdletBinding` to my PowerShell functions?: Yes, Atlas can be asked to add `CmdletBinding` and `SupportsShouldProcess` to destructive PowerShell functions. This ensures that your cmdlets properly honor `-WhatIf` and `-Confirm` parameters, aligning with best practices for robust PowerShell module development in 2026.

Try Atlas in your terminal

The terminal-native AI coding agent. Free core, single binary.

Install Atlas

Related guides

Migrate a Deprecated API Across Every Callsite with Atlas (2026 Workflow)

How to migrate a deprecated API across every callsite with Atlas in 2026: the lsp tool's findReferences enumerates callers, todowrite tracks them, apply_patch migrates each one.

Atlas for PowerShell: A Terminal-Native AI Coding Agent for Modules and Pester in 2026

Atlas is a terminal-native AI coding agent for PowerShell in 2026. It reads your .psm1 module and .psd1 manifest, adds SupportsShouldProcess, and runs Invoke-Pester behind a prompt.

Run Atlas Headless in CI with PowerShell in 2026

Automate Atlas in your PowerShell CI/CD pipelines. Learn to run Atlas headless, get machine-readable output, and integrate with Pester and PSResourceGet for robust automation.

Automate GitHub Issue and Pull Request Triage in PowerShell with Atlas in 2026

Streamline GitHub issue and pull request triage for PowerShell projects using Atlas. Automate responses, enforce safety, and integrate with your existing PowerShell toolchain in 2026.

Audit a PowerShell Repository with Parallel Subagents in Atlas in 2026

Sweep your PowerShell repository for issues without blowing your context window. Atlas uses parallel subagents and integrates with Pester, PSResourceGet, and PSScriptAnalyzer for efficient audits.

Trace a Runtime Bug from a PowerShell Stack Trace with Atlas in 2026

Pinpoint and fix PowerShell runtime bugs from production stack traces using Atlas. Leverage its AI-powered tools to navigate modules, cmdlets, and Pester tests without a debugger.

Plan a Multi-File Change Before Editing in PowerShell with Atlas in 2026

Design and review complex, multi-file PowerShell changes with Atlas's plan agent before modifying a single line of code. Leverage Pester, PSResourceGet, and PSScriptAnalyzer for a safe, integrated workflow.

Onboard to an Unfamiliar PowerShell Codebase with Atlas in 2026

PowerShell developers in 2026 use Atlas to quickly build a mental model of unfamiliar codebases. Leverage semantic search, Pester, and PSResourceGet for efficient onboarding.

Browse this resource hub