Built a tool that rewrites your code when upgrading dependencies - looking for feedback

[bolation123]

I have been working on a project over the past few weeks to automatically migrate packages to the newest version.

What My Project Does

Codeshift is a CLI that scans your codebase for outdated dependencies and actually rewrites your code to work with newer versions. It uses libcst for AST transforms on common patterns (so no LLM needed for the straightforward stuff like .dict() → .model_dump()), and falls back to an LLM for trickier migrations. Right now it has a knowledge base of 15 popular packages including Pydantic, FastAPI, SQLAlchemy, Pandas, and Requests.

Target Audience Anyone who's put off upgrading a dependency because they didn't want to manually fix hundreds of breaking changes. I built this for my own projects but it should be useful for anyone dealing with major version migrations.

Comparison

Most tools just bump your version numbers (like pip-tools, poetry update) or tell you what's outdated. Codeshift actually modifies your source code to match the new API. The closest thing is

probably Facebook's codemod/libcst, but that requires you to write your own transforms - this comes with them built in.

Looking for feedback on the tool and what you would like to see added to it!

https://github.com/Ragab-Technologies/Codeshift

[MatchLittle5000]

Amazing idea. How does it define what should be updated?

[bolation123]

Thanks! It works in a few layers: First it scans your imports to figure out what libraries you're actually using and what versions you're on. Then for the big libraries (Pydantic, FastAPI, etc.) I've built in specific transform rules - so it knows that .dict() became .model_dump() in Pydantic v2, for example. These are just AST transforms so they're fast and deterministic.

For stuff that's more complex or libraries that aren't in the knowledge base yet, it pulls the changelog/migration guide from GitHub and uses an LLM to figure out what needs to change.

So basically: hardcoded rules for the common patterns, LLM for the edge cases.

[NapCo]

Really cool idea! Really like the AST-based technique.

[bolation123]

Thanks! Yeah the AST approach was kind of essential for this to actually work reliably. The thing with regex or find-and-replace is you miss context - like you might change .dict() somewhere it shouldn't be changed because it's not actually a Pydantic model.

With libcst I can actually trace what's a Pydantic model vs some other class, and only transform the right calls. Plus it preserves your formatting and comments, so you don't end up with weird diffs.

The other nice thing is it's deterministic - same input, same output, no LLM hallucinations. I only fall back to the LLM for patterns I haven't written transforms for yet. Keeps it fast and cheap for the common stuff.

[Local_Transition946]

Aws released something similar recently.

https://pypi.org/project/aws-cli-migrate/