driftfix 0.1.0__tar.gz

driftfix-0.1.0/.github/workflows/ci.yml

@@ -0,0 +1,10 @@
+name: CI
+on: [push, pull_request]
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with: { python-version: "3.12" }
+      - run: pip install -e '.[dev]' && pytest -q tests

driftfix-0.1.0/.github/workflows/release.yml

@@ -0,0 +1,13 @@
+name: release
+on:
+  release:
+    types: [published]
+jobs:
+  pypi:
+    runs-on: ubuntu-latest
+    permissions: { id-token: write }  # PyPI trusted publishing, no token needed
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v6
+      - run: uv build
+      - uses: pypa/gh-action-pypi-publish@release/v1

driftfix-0.1.0/.gitignore

@@ -0,0 +1,6 @@
+.venv/
+__pycache__/
+*.egg-info/
+dist/
+.pytest_cache/
+.ruff_cache/

driftfix-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 driftfix contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

driftfix-0.1.0/PKG-INFO

@@ -0,0 +1,104 @@
+Metadata-Version: 2.5
+Name: driftfix
+Version: 0.1.0
+Summary: Dependabot bumps it. CI breaks. driftfix fixes the code.
+Project-URL: Repository, https://github.com/Gthejesraj/driftfix
+License-Expression: MIT
+License-File: LICENSE
+Requires-Python: >=3.10
+Requires-Dist: claude-agent-sdk>=0.2
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# driftfix
+
+**Dependabot bumps it. CI breaks. driftfix fixes the code.**
+
+Dependency bots open the upgrade PR, then leave you to fix whatever broke.
+driftfix finishes the job: it reads the failing tests, has Claude adapt your
+code to the new version, reruns your tests itself, and pushes the fix onto
+the same PR. If it can't get to green, it comments what it tried and commits
+nothing.
+
+```
+Dependabot PR (openai 0.28 → 1.x) → tests fail → Claude fixes code → tests rerun → ✅ commit on the PR
+                                                                              └→ ❌ comment only
+```
+
+## Benchmark
+
+Real breaking upgrades, each a small app with tests that pass on the old version and fail on the new one ([`bench/`](bench/)):
+
+| Package | Upgrade | Fixed | Cost | Diff |
+|---|---|---|---|---|
+| httpx | 0.27.2 → 0.28.1 | ✅ | $0.12 | 1 file changed, 4 insertions(+), 1 deletion(-) |
+| numpy | 1.26.4 → 2.5.3 | ✅ | $0.14 | 1 file changed, 5 insertions(+), 5 deletions(-) |
+| openai | 0.28.1 → 3.24.0 | ✅ | $0.29 | 1 file changed, 4 insertions(+), 3 deletions(-) |
+| pydantic | 1.10.21 → 2.13.5 | ✅ | $0.20 | 1 file changed, 11 insertions(+), 11 deletions(-) |
+| sqlalchemy | 1.4.54 → 2.1.3 | ✅ | $0.19 | 1 file changed, 7 insertions(+), 4 deletions(-) |
+| pydantic (6-file app, shared base model) | 1.10.21 → 2.13.5 | ✅ | $0.51 | 4 files changed, 47 insertions(+), 29 deletions(-) |
+
+6/6 fixed for $1.45 total, no test edits. The 6-file case runs with deprecation warnings as errors and includes a silent behavior change (v2 stops coercing numeric SKUs to strings). Rerun: `python bench/run.py` (or `--check` to validate cases for free).
+More cases welcome: add a folder under `bench/cases/`.
+
+## GitHub Action
+
+```yaml
+# .github/workflows/driftfix.yml
+name: driftfix
+on: pull_request
+permissions: { contents: write, pull-requests: write }
+jobs:
+  fix:
+    if: github.actor == 'dependabot[bot]'
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with: { ref: "${{ github.head_ref }}" }
+      - uses: Gthejesraj/driftfix@main
+        with:
+          anthropic-api-key: ${{ secrets.ANTHROPIC_API_KEY }}
+          setup: pip install -r requirements.txt
+          test: pytest -q
+```
+
+**Important:** workflows triggered by Dependabot can't read your normal repo
+secrets. Add `ANTHROPIC_API_KEY` under **Settings → Secrets → Dependabot**.
+
+Commits pushed with the default `GITHUB_TOKEN` don't re-trigger CI. Use a PAT
+or GitHub App token in `actions/checkout` if you want CI to rerun on the fix.
+
+## CLI
+
+```bash
+pip install driftfix
+# after upgrading a dependency and seeing tests fail:
+driftfix fix --package openai --from 0.28 --to 1.40 --test "pytest -q"
+```
+
+| Flag | Default | |
+|---|---|---|
+| `--test` | `pytest -q` | any command; exit 0 = green |
+| `--model` | `claude-opus-5` | |
+| `--budget` | `5` | max USD per run |
+| `--max-turns` | `50` | |
+| `--summary FILE` | | write the markdown report |
+
+## Guardrails
+
+- Your tests decide. driftfix reruns them after the agent finishes; the agent's word doesn't count.
+- Edits to dependency files (pinning back) are rejected.
+- Requires a clean git tree, so every change is a reviewable diff.
+- Never merges anything. The PR is still yours to review.
+- The agent runs with full tool access inside the checkout. Run it in CI or a throwaway clone.
+
+## Roadmap
+
+- More benchmark cases (pandas 2, Django, langchain), harder multi-file repos
+- npm / Renovate support
+- Provider mode: packages ship migration notes that driftfix reads
+
+## License
+
+MIT

driftfix-0.1.0/README.md

@@ -0,0 +1,91 @@
+# driftfix
+
+**Dependabot bumps it. CI breaks. driftfix fixes the code.**
+
+Dependency bots open the upgrade PR, then leave you to fix whatever broke.
+driftfix finishes the job: it reads the failing tests, has Claude adapt your
+code to the new version, reruns your tests itself, and pushes the fix onto
+the same PR. If it can't get to green, it comments what it tried and commits
+nothing.
+
+```
+Dependabot PR (openai 0.28 → 1.x) → tests fail → Claude fixes code → tests rerun → ✅ commit on the PR
+                                                                              └→ ❌ comment only
+```
+
+## Benchmark
+
+Real breaking upgrades, each a small app with tests that pass on the old version and fail on the new one ([`bench/`](bench/)):
+
+| Package | Upgrade | Fixed | Cost | Diff |
+|---|---|---|---|---|
+| httpx | 0.27.2 → 0.28.1 | ✅ | $0.12 | 1 file changed, 4 insertions(+), 1 deletion(-) |
+| numpy | 1.26.4 → 2.5.3 | ✅ | $0.14 | 1 file changed, 5 insertions(+), 5 deletions(-) |
+| openai | 0.28.1 → 3.24.0 | ✅ | $0.29 | 1 file changed, 4 insertions(+), 3 deletions(-) |
+| pydantic | 1.10.21 → 2.13.5 | ✅ | $0.20 | 1 file changed, 11 insertions(+), 11 deletions(-) |
+| sqlalchemy | 1.4.54 → 2.1.3 | ✅ | $0.19 | 1 file changed, 7 insertions(+), 4 deletions(-) |
+| pydantic (6-file app, shared base model) | 1.10.21 → 2.13.5 | ✅ | $0.51 | 4 files changed, 47 insertions(+), 29 deletions(-) |
+
+6/6 fixed for $1.45 total, no test edits. The 6-file case runs with deprecation warnings as errors and includes a silent behavior change (v2 stops coercing numeric SKUs to strings). Rerun: `python bench/run.py` (or `--check` to validate cases for free).
+More cases welcome: add a folder under `bench/cases/`.
+
+## GitHub Action
+
+```yaml
+# .github/workflows/driftfix.yml
+name: driftfix
+on: pull_request
+permissions: { contents: write, pull-requests: write }
+jobs:
+  fix:
+    if: github.actor == 'dependabot[bot]'
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with: { ref: "${{ github.head_ref }}" }
+      - uses: Gthejesraj/driftfix@main
+        with:
+          anthropic-api-key: ${{ secrets.ANTHROPIC_API_KEY }}
+          setup: pip install -r requirements.txt
+          test: pytest -q
+```
+
+**Important:** workflows triggered by Dependabot can't read your normal repo
+secrets. Add `ANTHROPIC_API_KEY` under **Settings → Secrets → Dependabot**.
+
+Commits pushed with the default `GITHUB_TOKEN` don't re-trigger CI. Use a PAT
+or GitHub App token in `actions/checkout` if you want CI to rerun on the fix.
+
+## CLI
+
+```bash
+pip install driftfix
+# after upgrading a dependency and seeing tests fail:
+driftfix fix --package openai --from 0.28 --to 1.40 --test "pytest -q"
+```
+
+| Flag | Default | |
+|---|---|---|
+| `--test` | `pytest -q` | any command; exit 0 = green |
+| `--model` | `claude-opus-5` | |
+| `--budget` | `5` | max USD per run |
+| `--max-turns` | `50` | |
+| `--summary FILE` | | write the markdown report |
+
+## Guardrails
+
+- Your tests decide. driftfix reruns them after the agent finishes; the agent's word doesn't count.
+- Edits to dependency files (pinning back) are rejected.
+- Requires a clean git tree, so every change is a reviewable diff.
+- Never merges anything. The PR is still yours to review.
+- The agent runs with full tool access inside the checkout. Run it in CI or a throwaway clone.
+
+## Roadmap
+
+- More benchmark cases (pandas 2, Django, langchain), harder multi-file repos
+- npm / Renovate support
+- Provider mode: packages ship migration notes that driftfix reads
+
+## License
+
+MIT

driftfix-0.1.0/action.yml

@@ -0,0 +1,66 @@
+name: driftfix
+description: Dependabot bumps it. CI breaks. driftfix fixes the code and pushes it to the PR.
+branding: { icon: tool, color: green }
+
+inputs:
+  anthropic-api-key: { required: true }
+  setup: { description: Command that installs your project's dependencies, default: "pip install -r requirements.txt" }
+  test: { description: Test command, default: "pytest -q" }
+  package: { description: Package that was upgraded (auto-detected on Dependabot PRs), default: "" }
+  model: { default: claude-opus-5 }
+  budget: { description: Max USD per run, default: "5" }
+
+runs:
+  using: composite
+  steps:
+    - id: meta
+      if: inputs.package == ''
+      uses: dependabot/fetch-metadata@v2
+
+    - uses: actions/setup-python@v5
+      with: { python-version: "3.12" }
+
+    - shell: bash
+      run: |
+        pip install -q "${{ github.action_path }}"
+        ${{ inputs.setup }}
+
+    - id: fix
+      shell: bash
+      env:
+        ANTHROPIC_API_KEY: ${{ inputs.anthropic-api-key }}
+      run: |
+        if [ -z "$ANTHROPIC_API_KEY" ]; then
+          echo "::error::ANTHROPIC_API_KEY is empty. Dependabot PRs only see Dependabot secrets: Settings → Secrets and variables → Dependabot."
+          exit 1
+        fi
+        set +e
+        driftfix fix \
+          --package "${{ inputs.package || steps.meta.outputs.dependency-names }}" \
+          --from "${{ steps.meta.outputs.previous-version }}" \
+          --to "${{ steps.meta.outputs.new-version }}" \
+          --test "${{ inputs.test }}" --model "${{ inputs.model }}" --budget "${{ inputs.budget }}" \
+          --summary "$RUNNER_TEMP/driftfix.md"
+        echo "code=$?" >> "$GITHUB_OUTPUT"
+
+    - if: steps.fix.outputs.code == '0'
+      shell: bash
+      run: |
+        git add -A && git reset -q -- ':(glob)**/__pycache__/**' ':(glob).pytest_cache/**'
+        git diff --cached --quiet && exit 0
+        git -c user.name="driftfix[bot]" -c user.email="driftfix@users.noreply.github.com" \
+          commit -qm "fix: adapt code to ${{ inputs.package || steps.meta.outputs.dependency-names }} upgrade"
+        git push
+
+    - if: always()
+      shell: bash
+      env: { GH_TOKEN: "${{ github.token }}" }
+      run: |
+        [ -f "$RUNNER_TEMP/driftfix.md" ] || exit 0
+        gh pr comment "${{ github.event.pull_request.number }}" --body-file "$RUNNER_TEMP/driftfix.md"
+
+    - if: steps.fix.outputs.code != '0'
+      shell: bash
+      run: |
+        echo "::error::driftfix could not fix this upgrade (exit ${{ steps.fix.outputs.code }}). See the PR comment."
+        exit 1

driftfix-0.1.0/bench/RESULTS.md

@@ -0,0 +1,8 @@
+| Package | Upgrade | Fixed | Cost | Diff |
+|---|---|---|---|---|
+| httpx | 0.27.2 → 0.28.1 | ✅ | $0.12 | 1 file changed, 4 insertions(+), 1 deletion(-) |
+| numpy | 1.26.4 → 2.5.3 | ✅ | $0.14 | 1 file changed, 5 insertions(+), 5 deletions(-) |
+| openai | 0.28.1 → 3.24.0 | ✅ | $0.29 | 1 file changed, 4 insertions(+), 3 deletions(-) |
+| pydantic | 1.10.21 → 2.13.5 | ✅ | $0.20 | 1 file changed, 11 insertions(+), 11 deletions(-) |
+| sqlalchemy | 1.4.54 → 2.1.3 | ✅ | $0.19 | 1 file changed, 7 insertions(+), 4 deletions(-) |
+| pydantic (6-file app, shared base model) | 1.10.21 → 2.13.5 | ✅ | $0.51 | 4 files changed, 47 insertions(+), 29 deletions(-) |

driftfix-0.1.0/bench/cases/httpx/app.py

@@ -0,0 +1,11 @@
+import httpx
+
+
+def make_client(wsgi_app) -> httpx.Client:
+    return httpx.Client(app=wsgi_app, base_url="http://testserver")
+
+
+def greeting(client: httpx.Client, name: str) -> str:
+    response = client.get("/hello", params={"name": name})
+    response.raise_for_status()
+    return response.text

driftfix-0.1.0/bench/cases/httpx/case.json

@@ -0,0 +1 @@
+{"package": "httpx", "old": "httpx==0.27.2", "new": "httpx>=0.28,<1"}

driftfix-0.1.0/bench/cases/httpx/pytest.ini

@@ -0,0 +1,2 @@
+[pytest]
+pythonpath = .

driftfix-0.1.0/bench/cases/httpx/tests/test_app.py

@@ -0,0 +1,14 @@
+from urllib.parse import parse_qs
+
+import app
+
+
+def hello(environ, start_response):
+    name = parse_qs(environ["QUERY_STRING"])["name"][0]
+    start_response("200 OK", [("Content-Type", "text/plain")])
+    return [f"hello {name}".encode()]
+
+
+def test_greeting():
+    with app.make_client(hello) as client:
+        assert app.greeting(client, "ada") == "hello ada"

driftfix-0.1.0/bench/cases/numpy/app.py

@@ -0,0 +1,19 @@
+import numpy as np
+
+
+def clean(xs: list[float]) -> np.ndarray:
+    a = np.array(xs, dtype=np.float_)
+    a[a < 0] = np.NaN
+    return a
+
+
+def total(xs: list[float]) -> float:
+    return float(np.product(xs))
+
+
+def all_positive(xs: list[float]) -> bool:
+    return bool(np.alltrue(np.array(xs) > 0))
+
+
+def as_bytes(xs: list[int]) -> np.ndarray:
+    return np.array(xs).astype(np.string_)

driftfix-0.1.0/bench/cases/numpy/case.json

@@ -0,0 +1 @@
+{"package": "numpy", "old": "numpy==1.26.4", "new": "numpy>=2,<3"}

driftfix-0.1.0/bench/cases/numpy/pytest.ini

@@ -0,0 +1,2 @@
+[pytest]
+pythonpath = .

driftfix-0.1.0/bench/cases/numpy/tests/test_app.py

@@ -0,0 +1,17 @@
+import math
+
+import app
+
+
+def test_clean():
+    out = app.clean([1.0, -1.0])
+    assert out[0] == 1.0 and math.isnan(out[1])
+
+
+def test_math():
+    assert app.total([2, 3]) == 6
+    assert app.all_positive([1, 2]) and not app.all_positive([1, -2])
+
+
+def test_bytes():
+    assert app.as_bytes([1, 22]).tolist() == [b"1", b"22"]

driftfix-0.1.0/bench/cases/openai/app.py

@@ -0,0 +1,9 @@
+import openai
+
+
+def summarize(text: str) -> str:
+    resp = openai.ChatCompletion.create(
+        model="gpt-4o-mini",
+        messages=[{"role": "user", "content": f"Summarize: {text}"}],
+    )
+    return resp["choices"][0]["message"]["content"]

driftfix-0.1.0/bench/cases/openai/case.json

@@ -0,0 +1 @@
+{"package": "openai", "old": "openai==0.28.1", "new": "openai>=1"}

driftfix-0.1.0/bench/cases/openai/pytest.ini

@@ -0,0 +1,2 @@
+[pytest]
+pythonpath = .

driftfix-0.1.0/bench/cases/openai/tests/test_app.py

@@ -0,0 +1,43 @@
+import json
+import threading
+from http.server import BaseHTTPRequestHandler, HTTPServer
+
+import pytest
+
+REPLY = {
+    "id": "x", "object": "chat.completion", "created": 0, "model": "gpt-4o-mini",
+    "choices": [{"index": 0, "finish_reason": "stop",
+                 "message": {"role": "assistant", "content": "short"}}],
+}
+
+
+class FakeOpenAI(BaseHTTPRequestHandler):
+    def do_POST(self):
+        self.rfile.read(int(self.headers["Content-Length"]))
+        body = json.dumps(REPLY).encode()
+        self.send_response(200)
+        self.send_header("Content-Type", "application/json")
+        self.send_header("Content-Length", str(len(body)))
+        self.end_headers()
+        self.wfile.write(body)
+
+    def log_message(self, *args):
+        pass
+
+
+@pytest.fixture
+def fake_openai(monkeypatch):
+    server = HTTPServer(("127.0.0.1", 0), FakeOpenAI)
+    threading.Thread(target=server.serve_forever, daemon=True).start()
+    url = f"http://127.0.0.1:{server.server_port}/v1"
+    monkeypatch.setenv("OPENAI_API_KEY", "test")
+    monkeypatch.setenv("OPENAI_BASE_URL", url)  # openai>=1
+    monkeypatch.setenv("OPENAI_API_BASE", url)  # openai<1
+    yield
+    server.shutdown()
+
+
+def test_summarize(fake_openai):
+    import app
+
+    assert app.summarize("long text") == "short"

driftfix-0.1.0/bench/cases/pydantic/app.py

@@ -0,0 +1,33 @@
+from pydantic import BaseModel, validator
+
+
+class User(BaseModel):
+    name: str
+    email: str
+
+    class Config:
+        orm_mode = True
+
+    @validator("email")
+    def lowercase(cls, v):
+        return v.lower()
+
+
+class Tags(BaseModel):
+    __root__: list[str]
+
+
+def load(data: dict) -> User:
+    return User.parse_obj(data)
+
+
+def dump(user: User) -> dict:
+    return user.dict()
+
+
+def from_row(row) -> User:
+    return User.from_orm(row)
+
+
+def tags(raw: list[str]) -> list[str]:
+    return Tags.parse_obj(raw).__root__

driftfix-0.1.0/bench/cases/pydantic/case.json

@@ -0,0 +1 @@
+{"package": "pydantic", "old": "pydantic==1.10.21", "new": "pydantic>=2,<3"}

driftfix-0.1.0/bench/cases/pydantic/pytest.ini

@@ -0,0 +1,2 @@
+[pytest]
+pythonpath = .

driftfix-0.1.0/bench/cases/pydantic/tests/test_app.py

@@ -0,0 +1,16 @@
+import app
+
+
+def test_roundtrip():
+    user = app.load({"name": "Ada", "email": "ADA@X.COM"})
+    assert app.dump(user) == {"name": "Ada", "email": "ada@x.com"}
+
+
+def test_from_row():
+    class Row:
+        name, email = "Bob", "B@Y.COM"
+    assert app.from_row(Row()).email == "b@y.com"
+
+
+def test_tags():
+    assert app.tags(["a", "b"]) == ["a", "b"]

driftfix-0.1.0/bench/cases/pydantic-shop/case.json

@@ -0,0 +1 @@
+{"package": "pydantic", "old": "pydantic==1.10.21", "new": "pydantic>=2,<3"}

driftfix-0.1.0/bench/cases/pydantic-shop/pytest.ini

@@ -0,0 +1,3 @@
+[pytest]
+pythonpath = .
+filterwarnings = error::DeprecationWarning

driftfix-0.1.0/bench/cases/pydantic-shop/shop/base.py

@@ -0,0 +1,17 @@
+import json
+from decimal import Decimal
+
+from pydantic import BaseModel
+
+
+class ShopModel(BaseModel):
+    """Base for every model in the shop. Payloads go out camelCase, without nulls."""
+
+    class Config:
+        orm_mode = True
+        allow_population_by_field_name = True
+        anystr_strip_whitespace = True
+        json_encoders = {Decimal: str}
+
+    def to_payload(self) -> dict:
+        return json.loads(self.json(by_alias=True, exclude_none=True))

driftfix-0.1.0/bench/cases/pydantic-shop/shop/catalog.py

@@ -0,0 +1,13 @@
+from shop.base import ShopModel
+from shop.models import Product
+
+
+class Catalog(ShopModel):
+    __root__: list[Product]
+
+    def skus(self) -> list[str]:
+        return [p.sku for p in self.__root__]
+
+
+def parse_catalog(raw_json: str) -> Catalog:
+    return Catalog.parse_raw(raw_json)

driftfix-0.1.0/bench/cases/pydantic-shop/shop/models.py

@@ -0,0 +1,35 @@
+from decimal import Decimal
+from typing import Optional
+
+from pydantic import Field, conlist, constr, root_validator, validator
+
+from shop.base import ShopModel
+
+
+class Product(ShopModel):
+    sku: str = Field(..., alias="productId")
+    name: constr(min_length=1)
+    price: Decimal
+    color: Optional[constr(regex=r"^#[0-9a-f]{6}$")] = None
+
+    @validator("price")
+    def positive(cls, v):
+        if v <= 0:
+            raise ValueError("price must be positive")
+        return v
+
+
+class LineItem(ShopModel):
+    product: Product
+    quantity: int = 1
+
+
+class Order(ShopModel):
+    items: conlist(LineItem, min_items=1)
+    total: Decimal = Decimal(0)
+
+    @root_validator
+    def compute_total(cls, values):
+        items = values.get("items") or []
+        values["total"] = sum((i.product.price * i.quantity for i in items), Decimal(0))
+        return values

driftfix-0.1.0/bench/cases/pydantic-shop/shop/service.py

@@ -0,0 +1,20 @@
+from decimal import Decimal
+
+from shop.models import LineItem, Order, Product
+
+
+def discounted(product: Product, percent: int) -> Product:
+    new_price = (product.price * (100 - percent) / 100).quantize(Decimal("0.01"))
+    return product.copy(update={"price": new_price})
+
+
+def place_order(rows: list[dict]) -> Order:
+    return Order(items=[LineItem.parse_obj(r) for r in rows])
+
+
+def product_fields() -> list[str]:
+    return list(Product.__fields__)
+
+
+def product_from_record(record) -> Product:
+    return Product.from_orm(record)

driftfix-0.1.0/bench/cases/pydantic-shop/tests/test_models.py

@@ -0,0 +1,35 @@
+from decimal import Decimal
+
+import pytest
+from pydantic import ValidationError
+
+from shop.models import Product
+
+
+LEGACY = {"productId": 123, "name": "  Mug  ", "price": "9.99"}  # upstream API sends numeric SKUs
+
+
+def test_legacy_payload_is_normalized():
+    p = Product(**LEGACY)
+    assert p.sku == "123"
+    assert p.name == "Mug"
+    assert p.price == Decimal("9.99")
+
+
+def test_payload_is_camel_case_without_nulls():
+    p = Product(**LEGACY)
+    assert p.to_payload() == {"productId": "123", "name": "Mug", "price": "9.99"}
+
+
+def test_populate_by_field_name():
+    assert Product(sku="A1", name="Cup", price=1).sku == "A1"
+
+
+@pytest.mark.parametrize("bad", [{"price": 0}, {"name": ""}, {"color": "red"}])
+def test_rejects_invalid(bad):
+    with pytest.raises(ValidationError):
+        Product(**{**LEGACY, **bad})
+
+
+def test_color_ok():
+    assert Product(**LEGACY, color="#a1b2c3").color == "#a1b2c3"

driftfix-0.1.0/bench/cases/pydantic-shop/tests/test_service.py

@@ -0,0 +1,42 @@
+import json
+from decimal import Decimal
+
+import pytest
+from pydantic import ValidationError
+
+from shop.catalog import parse_catalog
+from shop.service import discounted, place_order, product_fields, product_from_record
+from shop.models import Product
+
+MUG = {"productId": "M1", "name": "Mug", "price": "10.00"}
+
+
+def test_discount_does_not_mutate():
+    p = Product(**MUG)
+    d = discounted(p, 15)
+    assert (p.price, d.price) == (Decimal("10.00"), Decimal("8.50"))
+
+
+def test_order_total():
+    order = place_order([{"product": MUG, "quantity": 3}, {"product": {**MUG, "price": "1.50"}}])
+    assert order.total == Decimal("31.50")
+    assert order.to_payload()["total"] == "31.50"
+
+
+def test_empty_order_rejected():
+    with pytest.raises(ValidationError):
+        place_order([])
+
+
+def test_catalog():
+    assert parse_catalog(json.dumps([MUG, {**MUG, "productId": "M2"}])).skus() == ["M1", "M2"]
+
+
+def test_fields():
+    assert product_fields() == ["sku", "name", "price", "color"]
+
+
+def test_from_record():
+    class Record:
+        sku, name, price, color = "R1", "Plate", Decimal(3), None
+    assert product_from_record(Record()).sku == "R1"

driftfix-0.1.0/bench/cases/sqlalchemy/app.py

@@ -0,0 +1,29 @@
+from sqlalchemy import Column, Integer, String, create_engine, select
+from sqlalchemy.ext.declarative import declarative_base
+
+Base = declarative_base()
+
+
+class User(Base):
+    __tablename__ = "users"
+    id = Column(Integer, primary_key=True)
+    name = Column(String)
+
+
+def make_engine():
+    engine = create_engine("sqlite://")
+    Base.metadata.create_all(engine)
+    return engine
+
+
+def add_user(engine, name: str) -> None:
+    with engine.connect() as conn:
+        conn.execute(User.__table__.insert(), {"name": name})
+
+
+def names(engine) -> list[str]:
+    return [row[0] for row in engine.execute(select([User.name]).order_by(User.name))]
+
+
+def count(engine) -> int:
+    return engine.execute("SELECT count(*) FROM users").scalar()

driftfix-0.1.0/bench/cases/sqlalchemy/case.json

@@ -0,0 +1 @@
+{"package": "sqlalchemy", "old": "sqlalchemy==1.4.54", "new": "sqlalchemy>=2,<3"}

driftfix-0.1.0/bench/cases/sqlalchemy/pytest.ini

@@ -0,0 +1,2 @@
+[pytest]
+pythonpath = .

driftfix-0.1.0/bench/cases/sqlalchemy/tests/test_app.py

@@ -0,0 +1,9 @@
+import app
+
+
+def test_users():
+    engine = app.make_engine()
+    app.add_user(engine, "bob")
+    app.add_user(engine, "alice")
+    assert app.names(engine) == ["alice", "bob"]
+    assert app.count(engine) == 2

driftfix-0.1.0/bench/run.py

@@ -0,0 +1,78 @@
+"""Benchmark driftfix on real breaking upgrades.
+
+    python bench/run.py --check        # sanity: each case passes on old, fails on new (free)
+    python bench/run.py [case ...]     # run driftfix on each case (costs API credits)
+"""
+
+import json
+import re
+import shutil
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+
+CASES = Path(__file__).parent / "cases"
+TEST = ".venv/bin/python -m pytest -q"
+
+
+def sh(cmd: str, cwd: Path) -> subprocess.CompletedProcess:
+    return subprocess.run(cmd, shell=True, cwd=cwd, capture_output=True, text=True)
+
+
+def setup(case: Path, spec: str) -> Path:
+    """Copy a case into a fresh git repo with `spec` installed in .venv."""
+    repo = Path(tempfile.mkdtemp(prefix=f"driftfix-{case.name}-"))
+    shutil.copytree(case, repo, dirs_exist_ok=True)
+    (repo / ".gitignore").write_text(".venv/\n__pycache__/\n.pytest_cache/\n")
+    for cmd in (
+        "uv venv -q -p 3.12 .venv",
+        f"uv pip install -q -p .venv/bin/python pytest '{spec}'",
+        "git init -q && git add -A && git -c user.email=b@b -c user.name=bench commit -qm init",
+    ):
+        if (r := sh(cmd, repo)).returncode:
+            sys.exit(f"{case.name}: `{cmd}` failed\n{r.stderr}")
+    return repo
+
+
+def version(repo: Path, package: str) -> str:
+    code = f"import importlib.metadata as m; print(m.version('{package}'))"
+    return sh(f".venv/bin/python -c \"{code}\"", repo).stdout.strip()
+
+
+def main(args: list[str]) -> None:
+    check = "--check" in args
+    names = [a for a in args if a != "--check"] or sorted(p.name for p in CASES.iterdir())
+    rows = []
+    for name in names:
+        case = CASES / name
+        meta = json.loads((case / "case.json").read_text())
+        if check:
+            old_ok = sh(TEST, setup(case, meta["old"])).returncode == 0
+            new_ok = sh(TEST, setup(case, meta["new"])).returncode == 0
+            print(f"{name:12} old {'pass' if old_ok else 'FAIL'}  new {'pass' if new_ok else 'fail'}"
+                  f"  {'ok' if old_ok and not new_ok else '<-- broken case'}")
+            continue
+
+        repo = setup(case, meta["new"])
+        old = re.sub(r"^[^0-9]*", "", meta["old"])
+        new = version(repo, meta["package"])
+        report = repo / ".driftfix.md"
+        r = sh(f"driftfix fix --package {meta['package']} --from {old} --to {new} "
+               f"--test '{TEST}' --budget 1.5 --summary {report}", repo)
+        text = report.read_text() if report.exists() else r.stdout + r.stderr
+        cost = re.search(r"cost \$([\d.]+)", text)
+        diff = sh("git diff --stat -- . ':!.driftfix.md' | tail -1", repo).stdout.strip()
+        rows.append((name, f"{old} → {new}", "✅" if r.returncode == 0 else "❌",
+                     f"${cost.group(1)}" if cost else "?", diff))
+        print(*rows[-1], repo, sep="  |  ", flush=True)
+
+    if rows:
+        table = "| Package | Upgrade | Fixed | Cost | Diff |\n|---|---|---|---|---|\n"
+        table += "".join(f"| {' | '.join(row)} |\n" for row in rows)
+        (Path(__file__).parent / "RESULTS.md").write_text(table)
+        print("\n" + table)
+
+
+if __name__ == "__main__":
+    main(sys.argv[1:])

driftfix-0.1.0/pyproject.toml

@@ -0,0 +1,21 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "driftfix"
+version = "0.1.0"
+description = "Dependabot bumps it. CI breaks. driftfix fixes the code."
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+dependencies = ["claude-agent-sdk>=0.2"]
+
+[project.optional-dependencies]
+dev = ["pytest>=8"]
+
+[project.scripts]
+driftfix = "driftfix.cli:main"
+
+[project.urls]
+Repository = "https://github.com/Gthejesraj/driftfix"

driftfix-0.1.0/pytest.ini

@@ -0,0 +1,2 @@
+[pytest]
+testpaths = tests

driftfix-0.1.0/src/driftfix/cli.py

@@ -0,0 +1,138 @@
+"""driftfix: a dependency upgrade broke your tests, Claude fixes the code."""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import subprocess
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+
+# Pinning back to the old version is not a fix.
+MANIFESTS = {
+    "requirements.txt", "pyproject.toml", "setup.py", "setup.cfg", "Pipfile", "Pipfile.lock",
+    "poetry.lock", "uv.lock", "package.json", "package-lock.json", "yarn.lock", "pnpm-lock.yaml",
+}
+
+PROMPT = """\
+The dependency `{package}` was upgraded{versions}. The test suite now fails:
+
+$ {test_command}
+{output}
+
+Fix this repository's code so it works with the new version of `{package}`.
+- Read the package's changelog / migration guide for the relevant versions if you need to.
+- Change application code. Change tests only where they use `{package}`'s API directly.
+- Never pin, downgrade, or edit dependency files ({manifests}).
+- Never delete or skip tests to make them pass.
+- Run `{test_command}` to confirm the fix.
+Your final message must be only a short markdown summary of what changed and why, for a PR description."""
+
+
+@dataclass
+class TestRun:
+    passed: bool
+    output: str
+
+
+def run_tests(command: str, repo: Path, timeout: int) -> TestRun:
+    try:
+        proc = subprocess.run(
+            command, shell=True, cwd=repo, capture_output=True, text=True, timeout=timeout
+        )
+    except subprocess.TimeoutExpired:
+        return TestRun(False, f"timed out after {timeout}s")
+    lines = (proc.stdout + proc.stderr).splitlines()
+    return TestRun(proc.returncode == 0, "\n".join(lines[-150:]))
+
+
+def changed_files(repo: Path) -> list[str]:
+    out = subprocess.run(
+        ["git", "status", "--porcelain"], cwd=repo, capture_output=True, text=True, check=True
+    ).stdout
+    return [line[3:].split(" -> ")[-1] for line in out.splitlines()]
+
+
+def build_prompt(package: str, old: str | None, new: str | None, command: str, out: str) -> str:
+    versions = f" from {old or '?'} to {new}" if new else (f" from {old}" if old else "")
+    return PROMPT.format(
+        package=package, versions=versions, test_command=command, output=out,
+        manifests=", ".join(sorted(MANIFESTS)),
+    )
+
+
+async def run_agent(prompt: str, repo: Path, model: str, max_turns: int, budget: float) -> tuple[str, float]:
+    from claude_agent_sdk import ClaudeAgentOptions, ResultMessage, query
+
+    options = ClaudeAgentOptions(
+        cwd=repo,
+        model=model,
+        allowed_tools=["Read", "Edit", "Write", "Glob", "Grep", "Bash", "WebFetch", "WebSearch"],
+        permission_mode="bypassPermissions",  # headless; run in CI or a throwaway checkout
+        max_turns=max_turns,
+        max_budget_usd=budget,
+        setting_sources=["project"],  # repo's CLAUDE.md, not the user's personal config
+        skills=[],
+    )
+    summary, cost = "", 0.0
+    async for message in query(prompt=prompt, options=options):
+        if isinstance(message, ResultMessage):
+            summary, cost = message.result or "", message.total_cost_usd or 0.0
+    return summary, cost
+
+
+def fix(args: argparse.Namespace) -> int:
+    repo = args.repo.resolve()
+    if changed_files(repo):
+        print("Working tree is dirty. Commit or stash first so driftfix's edits are reviewable.")
+        return 2
+    before = run_tests(args.test, repo, args.timeout)
+    if before.passed:
+        print(f"Tests pass with {args.package} as installed. Nothing to fix.")
+        return 0
+    baseline = set(changed_files(repo))  # test-run artifacts like __pycache__
+
+    print(f"Tests fail after upgrading {args.package}. Handing off to Claude ({args.model})...")
+    prompt = build_prompt(args.package, args.from_version, args.to_version, args.test, before.output)
+    try:
+        summary, cost = asyncio.run(run_agent(prompt, repo, args.model, args.max_turns, args.budget))
+    except Exception as exc:  # still report on the PR instead of dying silently
+        summary, cost = f"Agent error: `{exc}`", 0.0
+
+    touched = [f for f in changed_files(repo) if f not in baseline]
+    pinned = [f for f in touched if Path(f).name in MANIFESTS]
+    after = run_tests(args.test, repo, args.timeout)  # don't trust the agent's word
+    ok = after.passed and bool(touched) and not pinned
+
+    status = "✅ Fixed" if ok else "❌ Not fixed"
+    report = f"## driftfix: {args.package}\n\n**{status}** · cost ${cost:.2f}\n\n{summary}\n"
+    if pinned:
+        report += f"\nRejected: agent edited dependency files {pinned}.\n"
+    if not after.passed:
+        report += f"\nTests still failing:\n```\n{after.output[-3000:]}\n```\n"
+    print(report)
+    if args.summary:
+        args.summary.write_text(report)
+    return 0 if ok else 1
+
+
+def main(argv: list[str] | None = None) -> int:
+    p = argparse.ArgumentParser(prog="driftfix", description=__doc__)
+    sub = p.add_subparsers(dest="command", required=True)
+    f = sub.add_parser("fix", help="fix code broken by a dependency upgrade")
+    f.add_argument("--package", required=True)
+    f.add_argument("--from", dest="from_version")
+    f.add_argument("--to", dest="to_version")
+    f.add_argument("--test", default="pytest -q", help="test command (default: pytest -q)")
+    f.add_argument("--repo", type=Path, default=Path("."))
+    f.add_argument("--model", default="claude-opus-5")
+    f.add_argument("--max-turns", type=int, default=50)
+    f.add_argument("--budget", type=float, default=5.0, help="max spend in USD (default: 5)")
+    f.add_argument("--timeout", type=int, default=600, help="test timeout in seconds")
+    f.add_argument("--summary", type=Path, help="write the markdown report here")
+    return fix(p.parse_args(argv))
+
+
+if __name__ == "__main__":
+    sys.exit(main())

driftfix-0.1.0/tests/test_fix.py

@@ -0,0 +1,62 @@
+import subprocess
+import sys
+from pathlib import Path
+
+from driftfix.cli import main
+import driftfix.cli as cli
+
+
+def make_repo(tmp_path: Path, ok: bool) -> Path:
+    (tmp_path / "app.py").write_text(f"OK = {ok}\n")
+    (tmp_path / "requirements.txt").write_text("lib==2\n")
+    for cmd in (["init", "-q"], ["add", "."], ["-c", "user.email=a@b", "-c", "user.name=a", "commit", "-qm", "init"]):
+        subprocess.run(["git", *cmd], cwd=tmp_path, check=True)
+    return tmp_path
+
+
+TEST = f"{sys.executable} -c 'import app; assert app.OK'"
+
+
+def run(tmp_path, agent, monkeypatch):
+    monkeypatch.setattr(cli, "run_agent", agent)
+    return main(["fix", "--package", "lib", "--test", TEST, "--repo", str(tmp_path)])
+
+
+def test_green_tests_skip_agent(tmp_path, monkeypatch):
+    async def agent(*a):
+        raise AssertionError("agent should not run")
+    assert run(make_repo(tmp_path, True), agent, monkeypatch) == 0
+
+
+def test_agent_fix_is_verified(tmp_path, monkeypatch):
+    repo = make_repo(tmp_path, False)
+    async def agent(prompt, *a):
+        assert "assert app.OK" in prompt  # failure output reaches the agent
+        (repo / "app.py").write_text("OK = True\n")
+        return "fixed", 0.1
+    assert run(repo, agent, monkeypatch) == 0
+
+
+def test_agent_lying_still_fails(tmp_path, monkeypatch):
+    async def agent(*a):
+        return "fixed, trust me", 0.1
+    assert run(make_repo(tmp_path, False), agent, monkeypatch) == 1
+
+
+def test_pinning_back_is_rejected(tmp_path, monkeypatch):
+    repo = make_repo(tmp_path, False)
+    async def agent(*a):
+        (repo / "requirements.txt").write_text("lib==1\n")
+        (repo / "app.py").write_text("OK = True\n")
+        return "pinned", 0.1
+    assert run(repo, agent, monkeypatch) == 1
+
+
+def test_agent_crash_is_reported(tmp_path, monkeypatch):
+    async def agent(*a):
+        raise RuntimeError("Not logged in")
+    summary = tmp_path / "report.md"
+    monkeypatch.setattr(cli, "run_agent", agent)
+    code = main(["fix", "--package", "lib", "--test", TEST, "--repo", str(make_repo(tmp_path, False)),
+                 "--summary", str(summary)])
+    assert code == 1 and "Not logged in" in summary.read_text()