Metadata-Version: 2.5
Name: reshoot
Version: 0.3.7
Summary: Agent skills and recording tools for repeatable software demo videos
Project-URL: Homepage, https://github.com/mumit/reshoot
Project-URL: Documentation, https://github.com/mumit/reshoot/tree/main/guide
Project-URL: Changelog, https://github.com/mumit/reshoot/blob/main/CHANGELOG.md
Project-URL: Issues, https://github.com/mumit/reshoot/issues
Author: Mumit Khan
License-Expression: MIT
License-File: LICENSE
Keywords: agent-skills,demo,gif,playwright,readme,screencast,video
Classifier: Development Status :: 4 - Beta
Classifier: Environment :: Console
Classifier: Intended Audience :: Developers
Classifier: Operating System :: MacOS
Classifier: Operating System :: POSIX :: Linux
Classifier: Programming Language :: Python :: 3
Classifier: Topic :: Multimedia :: Video
Classifier: Topic :: Software Development :: Documentation
Requires-Python: >=3.11
Requires-Dist: pillow>=10.1
Requires-Dist: pyobjc-framework-quartz>=10; sys_platform == 'darwin'
Requires-Dist: pyobjc-framework-vision>=10; sys_platform == 'darwin'
Requires-Dist: websockets>=12
Provides-Extra: browser
Requires-Dist: playwright==1.58.0; extra == 'browser'
Description-Content-Type: text/markdown

# reshoot

**Demos that stay current.**

Script a task in your app once. reshoot records it as a captioned MP4 and a
README GIF, checks that the result really appeared, and keeps the script beside
your code. When the UI changes, run it again: the same story, freshly recorded.

![The same notes task recorded before and after a UI update, from one reshoot storyboard](https://raw.githubusercontent.com/mumit/reshoot/main/docs/demo/reshoot.gif)

Before and after a UI change, from one storyboard.
[Watch the 21-second social cut](https://github.com/mumit/reshoot/blob/main/docs/demo/reshoot.mp4).

- **Re-record, don't redo.** The demo is a `storyboard.toml` of clicks, typing,
  captions and the result that should appear. Run it after every UI change.
- **Checked, not just captured.** Each run confirms that the result you named
  appeared, stops on the step whose control no longer matches, and scans the
  frames for email addresses, keys and faces before you share anything.
- **Your agent can drive it.** Skills for Claude Code and Codex write the story
  from your app, and a GitHub workflow records it again when the app changes and
  opens a pull request with the new video.

## Try it in a minute

```bash
uv tool install 'reshoot[browser]'
reshoot create        # make the notes demo and open it in the studio
```

It makes a made-up notes app and its story, records a preview in about 15
seconds, and opens [the studio](https://github.com/mumit/reshoot/blob/main/guide/studio.md): a page on your computer
where you change captions, timing, the look and the cut by pointing, then
make the final and accept it.

For your own app, start its demo server and run:

```bash
reshoot create http://127.0.0.1:3000/ --directory demo
```

Show one task in the browser that opens. Its toolbar adds a caption, checks a
result, and finishes with **Done**. Use a demo account and made-up data.

reshoot runs on macOS or Linux; [installation](https://github.com/mumit/reshoot/blob/main/guide/install.md) covers each.
[The tutorial](https://github.com/mumit/reshoot/blob/main/guide/step-by-step.md) goes further: change the demo, break the
app, watch the story stop on the step that broke, repair it, and compare.

## Or let your agent make it

Open **Claude Code or Codex** in your app's repository, or in an empty folder
if you only have a running app, and paste:

```text
Make a short demo with reshoot.
Read https://github.com/mumit/reshoot/blob/main/guide/agent-quickstart.md
and follow its setup and creation workflow.

Target: the app in this repository.
Choose one useful task with a clear visible result. Use synthetic demo data.
Produce a short captioned MP4 and a README GIF. Keep the recording source in
demo/ so it can be updated later.

Inspect a preview, then record a fresh final and open both exports for review.
Ask only for permissions or missing details needed to proceed.
```

Change `Target:` to a URL, or to a macOS app and its window, if there's no
source, and add a task if you have one.

What to expect, from [trials on four new apps](https://github.com/mumit/reshoot/blob/main/docs/validation/2026-10-23-cold-first-demo.md):
2 to 3 minutes in Claude Code, 5 to 9 in Codex. The agent writes `demo/` and
its skills, may ask to install reshoot and ffmpeg, then opens the MP4 and GIF.
Reply "accept" or ask for changes. Nothing is published. reshoot itself calls
no model and needs no API key: see
[what your agent needs](https://github.com/mumit/reshoot/blob/main/guide/agent-quickstart.md#what-your-agent-needs).

## The story is a file

```toml
[[beat]]
id = "search"
caption = "Find the matching note"
hold = 2.0
[[beat.action]]
type = "type"
target = {css = "#q"}
text = "bike"
[[beat.expect]]
type = "text"
target = {css = "#list li"}
contains = "Pick up the bikes"
```

reshoot types into the real page with a visible cursor, shows the caption, and
holds on the result. When the app renames `#q`, the run stops on that beat:
`type target {css = '#q'} matched 0 elements`. Fix the target, or pick the new
one in the studio, and run again.

## Keep it current

Accept a final once; that writes `demo/accepted/`, a small record to commit.
After the app changes, record again, compare and accept the update:

```bash
reshoot run demo/reshoot.toml
reshoot compare demo/accepted demo/latest --out demo/comparison.json
reshoot accept demo/latest
```

Or let CI do it: the [GitHub workflow](https://github.com/mumit/reshoot/blob/main/guide/ci.md) records the demo when the
app changes on `main` and opens a pull request with the new video, GIF and a
beat-by-beat comparison. A broken story fails on its beat and opens nothing.

## How it differs

| If you use | reshoot adds |
|---|---|
| Screen Studio, Loom, ScreenFlow | Re-recording on demand. You give up some hand polish; you never record the same flow by hand again |
| [VHS](https://github.com/charmbracelet/vhs) | The same idea for web apps and macOS windows. reshoot uses VHS for terminals |
| Playwright video | A cursor, typing, captions, zoom, cuts, a GIF, result checks and a privacy scan |
| Arcade, Supademo | Ordinary MP4 and GIF files, made locally from open source, that CI can refresh |

## What it records

| Show | How |
|---|---|
| A web app | Headless Chrome: the page only, never your desktop |
| A CLI or an agent at work | [VHS](https://github.com/charmbracelet/vhs) terminal recordings |
| A native app on macOS | One window, by its ID |
| A narrated explanation | Voiceover timed to the beats, music under it, subtitles |
| Other formats | Edits, portrait crops and size limits for each export |

[Platforms](https://github.com/mumit/reshoot/blob/main/guide/README.md#platforms) lists what runs where.

## Skills for Claude Code and Codex

| When | Skill | Ask for |
|---|---|---|
| The first demo | [reshoot-demo](https://github.com/mumit/reshoot/blob/main/skills/reshoot-demo/SKILL.md) | "Show a customer saving a search and seeing its results." |
| The app changed | [reshoot-refresh](https://github.com/mumit/reshoot/blob/main/skills/reshoot-refresh/SKILL.md) | "Record that task again with the updated UI." |
| Before sharing | [reshoot-review](https://github.com/mumit/reshoot/blob/main/skills/reshoot-review/SKILL.md) | "Check the final video and GIF against the accepted run." |

Skills are instructions for a coding agent, so they need one and its model; the
CLI on its own needs neither. The first-demo prompt installs them, and the
[agent quickstart](https://github.com/mumit/reshoot/blob/main/guide/agent-quickstart.md#install-the-skills-yourself) shows
other ways. The [skill catalog](https://github.com/mumit/reshoot/blob/main/skills/README.md) describes all ten.

## Where next

| To | Read |
|---|---|
| Learn it step by step | [The tutorial](https://github.com/mumit/reshoot/blob/main/guide/step-by-step.md) |
| Record your own app | [A web app](https://github.com/mumit/reshoot/blob/main/guide/your-app.md), or [a macOS window](https://github.com/mumit/reshoot/blob/main/guide/macos-window.md) |
| Change a demo | By pointing in [the studio](https://github.com/mumit/reshoot/blob/main/guide/studio.md), or by its [files](https://github.com/mumit/reshoot/blob/main/guide/customize.md) |
| See the cursor, zoom, captions and shapes | [How the videos look](https://github.com/mumit/reshoot/blob/main/guide/look.md) |
| Use it on a team | [Ownership, review, alerts and CI cost](https://github.com/mumit/reshoot/blob/main/guide/team.md) |
| Keep it current in CI | [GitHub Actions](https://github.com/mumit/reshoot/blob/main/guide/ci.md) |
| Look something up | [Project reference](https://github.com/mumit/reshoot/blob/main/guide/projects.md) · [Commands](https://github.com/mumit/reshoot/blob/main/guide/commands.md) · [Troubleshooting](https://github.com/mumit/reshoot/blob/main/guide/troubleshooting.md) |
| Rebuild the video above | [Before-and-after recipe](https://github.com/mumit/reshoot/blob/main/examples/promo/README.md) |

## Why reshoot exists

I made the launch video for [photosearch](https://github.com/mumit/photosearch)
this way, and pulled the tools and what I learned into reshoot. Keeping a
demo's story beside the app makes the work of making it pay off again every
time the product changes.

The [original notes recording](https://github.com/mumit/reshoot/blob/main/docs/demo/notes.mp4) and its
[source files](https://github.com/mumit/reshoot/blob/main/examples/notes/) are still here.

## Contributing

New pitfalls, skills and fixes are welcome. See [CONTRIBUTING.md](https://github.com/mumit/reshoot/blob/main/CONTRIBUTING.md)
for how to work on it and [ROADMAP.md](https://github.com/mumit/reshoot/blob/main/ROADMAP.md) for what's planned.

## License

MIT. See [LICENSE](https://github.com/mumit/reshoot/blob/main/LICENSE).
