All jobs

Add Dependabot to a Textual App

Yes. An agent adds a Dependabot config to your Poetry-managed Textual app, grouped and scheduled to match how you release, and opens a PR that says what will change.

Run this on RushOpens the console with this prompt ready to send, in a Project that has your repository.

What the agent does

The agent reads how the project declares and locks its dependencies before it writes the config, because Dependabot's pip ecosystem behaves differently for a requirements.txt, a Poetry project and a bare pyproject.toml. In an app laid out like Textualize/toolong, pyproject.toml is a Poetry project at version 1.5.0 with python = "^3.8", three runtime requirements (click ^8.1.7, textual ^0.58.0, typing-extensions ^4.9.0), a dev group with textual-dev ^1.4.0, poetry-core as the build backend and a tl console script pointing at toolong.cli:run. poetry.lock is lock version 2.0 and pins textual to 0.58.0 and click to 8.1.7. There is no .github/ directory at all: no workflows, no Dependabot, no issue templates. The code is 19 modules under src/toolong/, with cli.py building the Click command and ui.py the Textual application.

The agent adds .github/dependabot.yml with one pip entry for directory /, which is how Dependabot reads a Poetry project, on a weekly schedule, a cap on open pull requests, and two groups: one for minor and patch updates of every dependency and one for textual on its own, because this app's caret on ^0.58.0 holds the framework below 0.59 and a Textual bump is the one update that may need code changes rather than a merge. Each Dependabot pull request changes the requirement in pyproject.toml and the matching entries in poetry.lock, so the lockfile the pipx install in README.md resolves against stays consistent with the declared ranges.

Because the repository has no workflow, a Dependabot pull request would show no checks, and the agent says so in its description rather than hiding it. It runs poetry check and poetry lock --no-update in its sandbox to confirm the lockfile and the project file agree today, and poetry install followed by tl --version to confirm the app starts from the locked set, so the baseline the first Dependabot pull requests are measured against is known good. A github-actions ecosystem entry is left out on purpose, with a comment in the file saying to add it when a workflow exists.

The pull request description lists what Dependabot will open first, read from poetry show --outdated in the sandbox: which pins are behind their caret range and which, like textual, are blocked by the range and will arrive as a requirement change. That list is the part a maintainer reads, since it is the difference between a quiet weekly pull request and a major upgrade.

Start it with one API call

POST https://api.phoenix.so/o/{org}/sessions with this body:

{
  "agent": "claude",
  "input": "Add Dependabot to this Poetry-managed Textual app. Read pyproject.toml, poetry.lock, README.md and the src/ tree first, and confirm whether a .github directory exists. Add .github/dependabot.yml with a pip entry for / on a weekly schedule, an open-pull-requests-limit, a group for minor and patch updates of all dependencies and a separate group for textual, and a comment explaining that a github-actions entry should be added once a workflow exists. Run poetry check, poetry lock --no-update, poetry install and tl --version in your sandbox and paste the results into the pull request, together with poetry show --outdated so the maintainer sees which updates Dependabot will open first and which are held back by a caret range. Say plainly in the pull request that Dependabot pull requests will carry no checks until the repository has a workflow. Change no other file.",
  "resources": [
    {
      "url": "https://github.com/your-org/your-app"
    }
  ]
}
  1. Get an API key. In the console, open Settings, then API keys, and create a key for your org. Send it in the Authorization header as a Bearer token.
  2. Send the request. POST the body in request.json to https://api.phoenix.so/o/{org}/sessions, with your repository as the resources URL. The run starts in its own cloud sandbox.
  3. Read what came back. Follow the run on its live stream or wait for the run.completed webhook, then read the result and its trajectory.

What comes back

The pull request adds one file, .github/dependabot.yml, and nothing else. Its description has the poetry check and poetry lock --no-update output, the tl --version line from the installed app, the poetry show --outdated table from the sandbox, and a short note on which dependency is held below its next minor by a caret.

Once merged, Dependabot opens its first pull requests on the next weekly slot, one for the grouped minor and patch bumps and, when textual has a release the range allows or a requirement change is due, one for it alone. With no workflow in the repository, those pull requests show no checks; the description says that and names the add-github-actions-ci job as the usual next step.

Before merging, a reviewer picks the day and time zone for the weekly schedule, decides whether textual really deserves its own group, and whether the open pull request limit suits how often they merge.

Run it on every repository without a Dependabot config

An organisation with many Python tools sends this body once per repository to POST /o/{org}/sessions, each with its own repository in resources and a request_id that is a UUID v5 of the repository name, so a retried call returns the run already started rather than opening a second pull request. Each run reads its own project: a requirements.txt project gets a pip entry without groups by framework, a uv project gets the same entry pointed at its lockfile, and one that already has workflows gets a github-actions entry too.

A webhook_url on the key reports each run.completed with the pull request in result, so the person who started the batch sees which repositories now have a config without opening each one.

The use case this job follows, with its automation and trigger: Upgrade dependencies weekly.

Why run it on Rush?

A Dependabot file is ten lines, and most of them are decisions: which ecosystem key reads a Poetry lockfile, what to group, which dependency gets its own pull request, and what the first week of pull requests will look like. The agent reads the project and the lockfile, runs Poetry in its own sandbox to confirm the lockfile is consistent and the app installs, and reports the outdated set, so the maintainer sees the consequences before they merge rather than when the pull requests start arriving.

The run's record keeps the commands and their output, and the pull request repeats the parts a reviewer needs. Many repositories can be done at once, each with a config that reflects its own files rather than a template.

Frequently asked questions

Which Dependabot ecosystem reads a Poetry project?

pip. Dependabot detects pyproject.toml with a [tool.poetry] section and poetry.lock and updates both. There is no separate poetry value.

Why give textual its own group?

The app pins textual with ^0.58.0, which keeps it below 0.59, and the framework's releases are where the app's own code is most likely to need a change. A separate pull request lets the maintainer merge the routine bumps and look at the Textual one on its own terms.

Will the Dependabot pull requests be tested?

Not until the repository has a workflow. There is no .github/workflows/ directory today, so a Dependabot pull request shows no checks. The agent states that in its description; adding CI is a separate job.

Does the config touch the lockfile?

No. The pull request adds only .github/dependabot.yml. The poetry lock --no-update run in the sandbox is a check that poetry.lock already matches pyproject.toml, not a change.

More Textual jobs

The same job on other stacks

Keep reading