# 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 Rush](https://cloud.getrush.ai/run/add-dependabot/textual/). Opens 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`

```json
{
  "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.

## 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

- [Add GitHub Actions CI to a Textual App](https://getrush.ai/run/add-github-actions-ci/textual/)
- [Persist User Settings in a Textual App](https://getrush.ai/run/add-persistent-settings/textual/)
- [Add Pre-commit Hooks to a Textual App](https://getrush.ai/run/add-pre-commit-hooks/textual/)

## The same job on other stacks

- [Add Dependabot to a Tokio Project](https://getrush.ai/run/add-dependabot/tokio/)
- [Add Dependabot to a Vite React Monorepo](https://getrush.ai/run/add-dependabot/vite-react/)
- [Add Dependabot to a VitePress Site](https://getrush.ai/run/add-dependabot/vitepress/)

## Keep reading

- [How a Rush run works on your repository, from request to pull request](https://getrush.ai/cloud/)
- [Compare cloud agents, agent sandboxes and AI code review](https://getrush.ai/compare/)
- [Rush pricing: Free, Pro and Max](https://getrush.ai/pricing/)
