Grit

Grit uses abstract syntax tree (AST) parsing and pattern matching to automatically identify and rewrite code that depends on specific library versions. Rather than regex-based find-and-replace, it understands code structure semantically, enabling it to handle complex refactoring scenarios like API signature changes, renamed imports, and deprecated function calls across multiple files simultaneously. The system maintains type-aware transformations that preserve code semantics while updating to new dependency APIs.

Grit analyzes breaking changes between library versions (API removals, signature changes, renamed exports) and generates transformation rules automatically or semi-automatically. The system can ingest changelog data, API documentation diffs, or type definition changes to infer the migration patterns needed, reducing the manual effort of writing transformation rules from scratch. This capability bridges the gap between library maintainers publishing updates and developers needing to apply them.

Grit applies transformation rules across entire codebases in a single operation, handling file discovery, parallel processing, and conflict resolution. The execution engine traverses the codebase, identifies files matching transformation criteria, applies changes atomically, and generates a unified diff showing all modifications. It supports incremental application (only transforming changed files since last run) and can handle interdependent transformations where one change triggers another.

Grit provides a domain-specific language (DSL) for expressing code transformations that is language-agnostic at the rule level but compiles to language-specific AST operations. Rules are written in a declarative syntax that describes patterns to match and replacements to apply, with support for variable binding, conditionals, and multi-statement patterns. The DSL abstracts away language-specific AST details while allowing precise control over transformations through pattern matching and rewriting.

Grit integrates with Git to create branches, stage changes, and generate pull requests for transformations. Rather than directly modifying the working directory, it creates isolated branches with transformation changes, allowing developers to review diffs before merging. The system can automatically create PRs with summaries of changes, link to documentation, and trigger CI/CD pipelines to validate transformations before merge.

Grit analyzes dependency manifests (package.json, requirements.txt, etc.) to identify outdated versions, security vulnerabilities, and compatibility issues. It compares current versions against available updates, checks for breaking changes, and recommends upgrade paths that minimize risk. The system can prioritize updates by severity (security patches vs. feature releases) and compatibility impact, helping teams decide which upgrades to apply first.

Grit tracks which transformations have been applied to a codebase and can detect when a transformation has already been executed, preventing duplicate application. It maintains a transformation history (either in git metadata, a manifest file, or a remote service) that records which rules were applied, when, and to which files. This enables safe re-runs of transformation pipelines without corrupting code or applying changes multiple times.

Grit builds a dependency graph that spans multiple languages in a polyglot codebase, understanding how packages in one language depend on or interact with packages in another. For example, it can track how a Node.js service depends on a Python library, or how a Java backend uses a shared Go utility. This enables transformations that must coordinate changes across language boundaries, such as updating a shared API contract.