home / skills / a5c-ai / babysitter / codemod-executor

codemod-executor skill

/plugins/babysitter/skills/babysit/process/specializations/code-migration-modernization/skills/codemod-executor

This skill automates large-scale code transformations using AST tools, enabling safe refactors, migrations, and language upgrades across codebases.

npx playbooks add skill a5c-ai/babysitter --skill codemod-executor

Review the files below or copy the command above to add this skill to your agents.

Files (2)

SKILL.md

2.8 KB

---
name: codemod-executor
description: Execute automated AST-based code transformations for large-scale refactoring and migration
allowed-tools: ["Bash", "Read", "Write", "Grep", "Glob", "Edit"]
---

# Codemod Executor Skill

Executes automated code transformations using AST-based tools for large-scale refactoring, framework migrations, and language version upgrades.

## Purpose

Enable automated code transformations for:
- Framework migration (React, Angular, Vue)
- Language version upgrades
- API deprecation handling
- Pattern standardization
- Large-scale refactoring

## Capabilities

### 1. AST-Based Transformations
- Parse source code to AST
- Apply transformation rules
- Generate modified source
- Preserve code style

### 2. Pattern Matching and Replacement
- Define source patterns
- Specify target patterns
- Handle edge cases
- Support wildcards and captures

### 3. Multi-File Transformations
- Apply across entire codebase
- Handle import updates
- Coordinate cross-file changes
- Manage side effects

### 4. Dry-Run Preview
- Preview changes before applying
- Generate diff reports
- Estimate impact scope
- Identify risky transformations

### 5. Rollback Support
- Create transformation checkpoints
- Enable selective rollback
- Track applied codemods
- Maintain change history

### 6. Custom Codemod Creation
- Define new transformation rules
- Test codemods in isolation
- Document transformation logic
- Share across teams

## Tool Integrations

| Tool | Language | Integration Method |
|------|----------|-------------------|
| jscodeshift | JavaScript/TypeScript | CLI |
| ts-morph | TypeScript | Library |
| Rector | PHP | CLI |
| Scalafix | Scala | CLI |
| OpenRewrite | Java | CLI / Maven |
| Bowler | Python | CLI |
| ast-grep | Multi-language | CLI / MCP |
| gofmt -r | Go | CLI |

## Output Schema

```json
{
  "executionId": "string",
  "timestamp": "ISO8601",
  "codemod": {
    "name": "string",
    "version": "string",
    "description": "string"
  },
  "results": {
    "filesProcessed": "number",
    "filesModified": "number",
    "filesSkipped": "number",
    "transformations": "number"
  },
  "changes": [
    {
      "file": "string",
      "transformations": [
        {
          "type": "string",
          "line": "number",
          "before": "string",
          "after": "string"
        }
      ]
    }
  ],
  "errors": [],
  "warnings": []
}
```

## Integration with Migration Processes

- **code-refactoring**: Large-scale refactoring
- **framework-upgrade**: Framework migrations
- **language-version-migration**: Syntax upgrades
- **code-translation**: Language conversion assist

## Related Skills

- `refactoring-assistant`: Suggests transformations
- `static-code-analyzer`: Pre-transformation analysis

## Related Agents

- `code-transformation-executor`: Orchestrates codemods
- `framework-upgrade-specialist`: Framework-specific codemods

Overview

This skill executes automated AST-based code transformations to support large-scale refactoring, framework migrations, and language upgrades. It provides deterministic, resumable runs with dry-run previews, rollback checkpoints, and cross-file coordination to minimize manual effort and risk.

How this skill works

The skill parses source files into ASTs, applies defined transformation rules or codemods, and generates modified source while preserving style. It can run across an entire repository, update imports and cross-file references, produce diff reports for dry runs, and record checkpoints to enable selective rollback and audit trails.

When to use it

Migrating a project between frameworks (React, Angular, Vue) or library versions
Upgrading language syntax or applying automated API deprecations
Applying consistent code style or pattern standardization across a large codebase
Performing multi-file refactors that require coordinated import and reference updates
Testing and validating codemods before committing changes using dry-run previews

Best practices

Start with a dry-run to generate diffs and estimate impact before applying changes
Create small, well-documented codemods and test them in isolation first
Use checkpoints for long-running transformations so you can rollback selectively
Integrate with static analysis to identify risky areas and reduce false positives
Track applied transformations and include metadata (name, version, description) for auditing

Example use cases

Convert class components to function components and hooks across a React codebase
Update deprecated API calls to their new signatures and adjust imports project-wide
Standardize error-handling patterns or logging statements across multiple services
Migrate TypeScript syntax to a new compiler target and fix incompatible constructs
Batch-rename identifiers and propagate changes to all referencing files

FAQ

Can I preview changes before applying them?

Yes. The skill supports dry-run previews that produce diffs, estimate scope, and highlight risky transformations.

How do rollbacks work?

Each execution can create checkpoints and record applied transformations, enabling selective rollback to a prior checkpoint or undoing specific changes.

Which AST tools are supported?

The skill integrates with common tools like jscodeshift, ts-morph, OpenRewrite, and language-specific CLIs; custom integrations can be added.