thunc 0.2.2__tar.gz → 0.3.0__tar.gz

thunc-0.3.0/.github/release-notes/v0.2.2.md

@@ -0,0 +1,74 @@
+thunc 0.2.2 makes **agents use their tools reliably**, especially on Claude Code, and makes calls faster. Agents on Claude Code now make native tool calls instead of writing each action as JSON text, a failed step is retried instead of ending the run, and the agent's tools fill gaps that a new tool-use benchmark found.
+
+| 8 tool-heavy tasks, Claude Sonnet 5.5 | Passed | Seconds per task | $ per task |
+|---|---|---|---|
+| thunc 0.2.1 agents on Claude Code | 12/24 | 99 | 0.084 |
+| **thunc 0.2.2 agents on Claude Code** | **24/24** | **10** | **0.022** |
+| Claude Code itself, for reference | 24/24 | 11 | 0.069 |
+
+On Claude Opus 5.5 both versions passed every task, but 0.2.2 took 15 seconds and $0.051 a task instead of 44 seconds and $0.264.
+
+```bash
+pip install --upgrade thunc
+```
+
+```python
+import thunc
+
+thunc.configure(backend="claude-code")  # agents now make native tool calls here
+fixer = thunc.Agent("fixer", workdir=".", permissions=["write:src/**", "run:pytest"])
+
+
+@fixer.task
+def make_tests_pass() -> str:
+    """Run the tests in services/api and fix what fails. Say what you changed."""
+    ...
+
+
+run = fixer.run(make_tests_pass)  # run.commands, run.files_changed, and any retries in run.session
+```
+
+```bash
+thunc run --profile my_script.py  # where the time went: model time, thunc's own, per tool
+```
+
+**Agents on Claude Code make native tool calls** ([#46](https://github.com/Eltarras/thunc/pull/46))
+- The agent's tools are an MCP server that one `claude -p` process per run calls, and thunc carries out each call with its own tools, permissions and run record. Before, the model wrote each action as JSON text. Current models slip back into their trained tool calls: they invented tool results and ran on to the timeout, or the CLI refused a tool call it couldn't parse.
+- Calls from one model reply count as one step. A turn without a tool call gets a nudge, and a turn that ends in an error gets a second chance, both in the same session.
+- **Fallback:** with a `claude` CLI too old for these options, or with MCP servers turned off by a policy, a run falls back to the text protocol with a warning. `protocol="native"` raises instead, and `protocol="text"` keeps the old way.
+- The CLI runs in the agent's `workdir`, so the environment details it adds to the prompt name the right folder.
+
+**Steadier runs** ([#46](https://github.com/Eltarras/thunc/pull/46))
+- **A failed step is retried** twice before the run fails, and each retry is logged in the run record. This covers timeouts, lost connections, rate limits, server errors and CLI calls that end in an error (`thunc.errors.TransientError`). Before, one bad call ended the run.
+- A text-protocol step on Claude Code or Codex now times out after 120 seconds instead of the whole 300-second `timeout`.
+
+**Better tools for agents** ([#46](https://github.com/Eltarras/thunc/pull/46))
+- **`run` takes `cwd`**: a folder inside `workdir` to run the command in.
+- **The `shell` permission** (opt-in) runs command lines through the system shell, so pipes, `&&`, `cd` and redirects work. It can't be combined with `!run:` rules, since a shell command line can't be checked word by word.
+- **`search` takes `glob`**: `*.py` matches by file name, `src/**/*.ts` by path.
+- **Git-aware `list` and `search`**: in a git repository they leave out what git ignores, so a stale `build/` copy no longer crowds out the real source.
+- **Long command output keeps its start and its end**, so an agent sees the first error as well as the summary.
+
+**Faster calls** ([#45](https://github.com/Eltarras/thunc/pull/45))
+- **The `anthropic` and `openai` backends reuse their connections**: one SDK client per process instead of a new TCP and TLS handshake each call. In a local benchmark with 60 ms of connection setup, 20 calls in a row went from 1.47 s to 68 ms.
+- **Text-protocol agents can act several times per reply** (Codex and `protocol="text"`), with a JSON array of independent actions. On Codex, the prompt eval took fewer replies (fix / review / analysis: 6.0 / 4.8 / 5.0 → 5.0 / 3.0 / 3.6) and less time (37 / 27 / 27 s → 29 / 19 / 21 s).
+- **The `codex` backend returns as soon as the answer arrives**, without waiting about 0.4 s for Codex to shut down.
+- **`thunc run --profile SCRIPT`** (or `-m module`) reports where a program's time went, per function: calls, cache hits, retries, failures, model time against thunc's own, and time per tool for agents. `python -m benchmarks` runs a dependency-free benchmark suite.
+
+**Tested**
+- Offline tests run on Python 3.10–3.14 on Ubuntu, and on Windows. Temporal integration tests run on Python 3.10 and 3.14.
+- The MCP path has an end-to-end test with a fake `claude` that starts the real tool server, covering parallel and serial calls, permissions, errors and the fallback.
+- Live: the tool-use benchmark (`live_tests/bench_tooluse.py`, with its report in `live_tests/bench_tooluse_report.md`) on Sonnet 5.5 and Opus 5.5, the prompt eval on Claude Code (45/45), and the live tests on Claude Code.
+- The agent loops on the Claude and OpenAI APIs haven't had a live tool-use benchmark yet.
+
+**Behavior changes**
+- Agents on `claude-code` make native tool calls by default, and fall back to the text protocol if they can't.
+- In a git repository, `list` and `search` leave out what git ignores. A folder named explicitly is still listed and searched.
+- Long command output keeps its start as well as its end.
+- The `claude-code` backend loads none of your Claude Code settings (`--setting-sources ""`). No `CLAUDE.md`, settings or hooks reach thunc's calls, plain function calls included, so a folder you point an agent at can't instruct it unless you pass `follow=`.
+- Durable runs on Claude Code still use the text protocol.
+- Nothing is removed.
+
+Still beta: expect bugs, and the API may change. Known issues are listed in [CONTRIBUTING.md](https://github.com/Eltarras/thunc/blob/main/CONTRIBUTING.md#known-issues), and every change is in [CHANGELOG.md](https://github.com/Eltarras/thunc/blob/main/CHANGELOG.md).
+
+**Full changelog:** https://github.com/Eltarras/thunc/compare/v0.2.1...v0.2.2

thunc-0.3.0/.github/release-notes/v0.2.3.md

@@ -0,0 +1,80 @@
+thunc 0.2.3 is the last 0.2 release. It makes **native tool calls the way agents work wherever they run**: on Codex now, as on Claude Code, and in durable runs on Claude Code, which pick up after a crash mid-call. Durable agents can take `tools=`, the Claude API agent path no longer loses runs to `max_tokens` or a stalled reply, and `edit` can change many places at once.
+
+| 8 tool-heavy tasks, Claude Sonnet 5.5, 3 runs each | Passed | Seconds per task | $ per task |
+|---|---|---|---|
+| thunc 0.2.2 agents, text protocol (Codex, durable runs, fallbacks) | 20/24 | 47 | 0.084 |
+| **thunc 0.2.3 agents, text protocol** | **24/24** | **27** | 0.082 |
+| thunc 0.2.3 agents on Claude Code, native calls | 24/24 | 8 | 0.021 |
+| Claude Code itself, for reference | 24/24 | 10 | 0.078 |
+
+Through the Claude API, thunc's agents passed 8 of 8 on Sonnet 5.5 ($0.023 a task) and on Opus 5.5 ($0.049 a task). On Codex, native calls took 30 seconds a task, against 45 for the text protocol 0.2.2 used there and 27 for Codex itself (16 of 16 each).
+
+```bash
+pip install --upgrade thunc
+```
+
+```python
+import thunc
+
+thunc.configure(backend="codex")  # agents now make native tool calls here too
+
+
+def find_issue(title: str) -> int:  # a tool is your own code, with a docstring for the model
+    """Find an open issue by title. Returns its number, or 0."""
+    return tracker.find(title)
+
+
+triage = thunc.Agent("triage", workdir=".", tools=[find_issue], effort="high")
+
+
+@triage.task
+def flaky_tests() -> list[str]:
+    """Run the tests three times and list the ones that fail only sometimes."""
+    ...
+```
+
+```python
+# On a Temporal worker: durable runs take the agent's own tools now, and name those that may run
+# again after a crash.
+registry.agent_task("triage", flaky_tests, version="1", workspace_id="repo", retry_safe_tools=["find_issue"])
+```
+
+**Native tool calls on Codex** ([#55](https://github.com/Eltarras/thunc/pull/55))
+- The agent's tools are an MCP server that Codex calls, through the same relay as Claude Code: thunc carries out each call with its own tools, permissions and run record. Codex's own tools and your `~/.codex` config stay out, its sandbox stays read-only, and only thunc's server is approved to run without asking.
+- A turn that ends without `finish`, or fails, is continued with `codex exec resume`. The run's Codex session is deleted when the run ends.
+- **Fallback:** when Codex can't start them, a run uses the text protocol with a warning. `protocol="native"` raises instead, and `protocol="text"` keeps the old way.
+
+**Durable runs** ([#56](https://github.com/Eltarras/thunc/pull/56), [#57](https://github.com/Eltarras/thunc/pull/57))
+- **On Claude Code, native calls in segments.** One activity keeps one `claude -p` process for many model replies, and checkpoints the run and Claude Code's session before each reply's calls. If the worker stops or the CLI dies, the retried activity restores the session and continues it with `--resume`. The call that was in flight, asked for again, gets its old journal entry: it's replayed, waits for `resolve()`, or runs. Never twice.
+- **`tools=`.** Each call of the agent's own functions is journaled like a command: recorded before it runs and after, replayed when completed, and waiting for `resolve()` if a worker stopped mid-call. `retry_safe_tools=` names the ones that may simply run again.
+
+**The Claude API agent path** ([#52](https://github.com/Eltarras/thunc/pull/52))
+- **`Agent(effort=...)`** on every backend. Claude 4.6 and later on the API get `"high"` by default; Claude Opus 5.5's own default is `"medium"`, which is low for agentic coding.
+- Replies are streamed with room for 64,000 tokens. A reply cut off at `max_tokens` gets an error result for its calls instead of ending the run, `pause_turn` carries on, and a reply that sends nothing for `timeout` seconds is stopped and asked again (one Opus reply in the benchmark sent nothing for an hour).
+- Old tool results are cleared on long runs (context editing), tools are strict where the model and schema allow, and connection errors, rate limits and server errors are retried as a step.
+
+**Steadier agents everywhere** ([#51](https://github.com/Eltarras/thunc/pull/51), [#52](https://github.com/Eltarras/thunc/pull/52), [#53](https://github.com/Eltarras/thunc/pull/53))
+- **The text protocol reads replies that aren't only the action**: the first complete action amid prose, a fence, `<invoke>` markup or made-up results, with a note to the model to keep to JSON. On Claude Code, a text step stops as soon as its action has arrived.
+- **`finish` in the same reply as other calls is refused** (except beside `remember`): in the benchmark, a run returned a guess written before its own read came back.
+- **The model is told when few steps are left**, in its last three replies before `max_steps`.
+
+**Better tools** ([#50](https://github.com/Eltarras/thunc/pull/50), [#51](https://github.com/Eltarras/thunc/pull/51), [#49](https://github.com/Eltarras/thunc/pull/49))
+- **`edit` takes `replace_all`, and `edits`** for several changes to one file in one call, all made or none.
+- **`edit` no longer needs a prior `read`**: it only changes text the agent quotes exactly. `write` still replaces only a file read with `read`.
+- **Large system prompts work on Claude Code**: the prompt goes in a file, not on the command line, where large `follow=` files could pass the operating system's limit.
+
+**Tested**
+- Offline tests run on Python 3.10–3.14 on Ubuntu, and on Windows; Temporal integration tests on Python 3.10 and 3.14, including a Claude Code run whose CLI dies mid-run. Tests can't reach a real `claude`, `codex` or `jev`.
+- Live: the tool-use benchmark on Claude Code (Sonnet 5.5), the Claude API (Sonnet 5.5 and Opus 5.5) and Codex, with the results in `live_tests/bench_tooluse_report.md`; a durable run on real Claude Code with the CLI killed after its first tool result, which finished with each effect done once.
+
+**Behavior changes**
+- Agents on `codex` make native tool calls by default, and fall back to the text protocol if they can't.
+- Durable runs on `claude-code` make native tool calls. Runs already in progress keep the text protocol.
+- Agents on the Claude API think at effort `high` on Claude 4.6 and later.
+- `edit` no longer needs a prior `read`; `write` still does.
+- `finish` in the same reply as other calls is refused, except beside `remember`.
+- Nothing is removed.
+
+**Known issues:** on Codex, native calls count each tool call as a step, so a long task reaches `max_steps` sooner, and their tokens aren't reported. Durable runs on Codex use the text protocol. On a fix in a long file, native calls take about twice Claude Code's steps. The full list is in [CONTRIBUTING.md](https://github.com/Eltarras/thunc/blob/main/CONTRIBUTING.md#known-issues), and every change is in [CHANGELOG.md](https://github.com/Eltarras/thunc/blob/main/CHANGELOG.md).
+
+**Full changelog:** https://github.com/Eltarras/thunc/compare/v0.2.2...v0.2.3

thunc-0.3.0/.github/release-notes/v0.3.0.md

@@ -0,0 +1,86 @@
+thunc 0.3.0 lets you **watch a program's calls and agent runs live**. `thunc watch app.py` runs your program with a dashboard in the terminal: the calls waiting on a model, retries and why each reply was rejected, timings for each function, each agent's steps as they happen, and the `--profile` report when the program ends. A program needs nothing added to be watched.
+
+It also brings an experiment, **thunc write**: a function declared with `@thunc.function(write=True)` writes its own body into your file on its first call, and runs as plain Python from then on. A program that uses neither behaves exactly as in 0.2.3.
+
+```bash
+pip install --upgrade "thunc[watch]"
+```
+
+```bash
+thunc watch support_inbox.py --limit 20   # a script and its arguments, as with thunc run
+thunc watch -m myapp.triage               # a module
+thunc watch -- uv run app.py              # any command
+thunc watch --agents                      # agent runs in ./.thunc_agents, from any process
+thunc watch --plain app.py                # one line per event, for CI logs and pipes
+```
+
+```
+ thunc watch  support_inbox.py                     claude-code/sonnet   00:18.0   ● running
+ 1 Overview   2 Agents   3 Calls   4 Summary
+────────────────────────────────────────────────────────────────────────────────────────────
+ IN FLIGHT  4 running
+   ⠙ draft_reply       ticket="Password reset email never… attempt 1    4.2s  ████████████
+   ⠙ urgency           ticket="Refund still not showing a… attempt 2    4.1s  ██████████░░
+   FUNCTION          CALLS  CACHED  RETRIES  FAILED      MEAN       P95     MODEL   RECENT
+   category              8       0        0       0      1.5s      2.5s     11.7s   ▃▄▅█▆▇▃▄
+   urgency               7       0        1       0      2.4s      4.7s     16.9s   ▂▄▄▆▃█▅
+ AGENTS  0 running
+   ✓ repo-guide      tests_for(feature="caching")            finished · 6 steps       12.4s
+ EVENTS
+   17:38:13  ✓ find_order      → Order(id='A-1043')                                    1.8s
+   17:38:15  ↻ urgency         attempt 1: not valid JSON: 'high'                       2.8s
+```
+
+**The dashboard** ([#59](https://github.com/Eltarras/thunc/pull/59))
+- **Five screens:** Overview (calls in flight, a table per function, running agents, results per second, recent events), Agents (each run's steps, time split, changed files and denials), Calls (each attempt of a call: the reply and why it was rejected), Summary (the `thunc run --profile` tables, opened when the program ends) and Output (what the program printed).
+- **Mouse or keys.** Click a row to select it and again to open it, or use `↑` `↓` and `⏎`. `f` shows only retries, failures and denials; `p` pauses the display while the program keeps running; `?` lists every key.
+- **`--agents [DIR]`** follows the agent runs recorded in a folder, from another terminal, a web app or a worker. A run whose process died partway through shows as interrupted.
+- **`--save-events` and `--replay`** keep a run and play it back, which is a good thing to attach to a bug report. `--replay` also plays one agent run's session record.
+- **`--plain`** prints one line per result, retry and agent step to stderr, then the report. It's what you get when the output isn't a terminal.
+
+**How it's packaged**
+- The dashboard is a Rust binary in its own package, [thunc-watch](https://pypi.org/project/thunc-watch/) 0.1, with wheels for macOS, Linux (glibc and musl) and Windows. `thunc[watch]` installs it, so thunc itself stays pure Python with no dependencies. It's also on your `PATH` as `thunc-watch`.
+- Without it, `thunc watch` says how to install it.
+
+**`THUNC_EVENTS`**
+- When `THUNC_EVENTS` names a file, thunc appends one JSON line to it per call start, model reply, call end, agent tool call and agent end; `thunc watch` sets it for the program it runs. To watch a program started some other way, set it yourself and run `thunc watch --events FILE`.
+- Inputs, replies and values are cut to 120-character previews; `--capture` (or `THUNC_EVENTS_CAPTURE=1`) sends them whole. Like a trace, they can contain personal data.
+- When it isn't set, nothing is written.
+
+**thunc write, experimental** ([#63](https://github.com/Eltarras/thunc/pull/63), [#64](https://github.com/Eltarras/thunc/pull/64))
+
+> **Experimental.** Its behavior, options and the code it writes may change, or it may be removed, in a later release without a deprecation period. It edits your source files, only while you develop; review each change as a diff before you commit it.
+
+```python
+@thunc.function(write=True)
+def minutes(duration: str) -> int:
+    """Convert a duration like '1h 30m', '90 min' or '2 hours' to whole minutes."""
+    ...
+
+
+minutes("1h 30m")  # -> 90, and minutes() is now Python in your file
+```
+
+```
+thunc: writing minutes() in durations.py (first call)
+thunc: checked against 6 model answers: all agree
+thunc: wrote durations.py lines 5-27 in 14s (answer 4s, draft 11s, test calls 9s; side by side). Removed @thunc.function. Review: git diff durations.py
+```
+
+- **On the first call**, three requests start side by side: the call's answer, a draft of the body from the docstring and signature, and five test calls, each answered by the model on its own. The draft is linted, run on the call and the test calls, and has to match every answer; one that doesn't goes back with the failing calls, up to three drafts.
+- **A passing draft goes into the file** in place of `...`, the decorator is removed, the checked calls become doctest examples, and the call runs the new code.
+- **When it isn't written**, because the task needs judgment or no draft passed, the call returns the model's answer and the file is untouched. The reason is kept in `.thunc_write/` until the docstring or signature changes.
+- **It's refused, with a warning,** in CI or with `THUNC_WRITE=0` (set it in production), outside your project, and for read-only, installed or changed files and nested functions.
+- **`thunc write FILE::FUNCTION [--dry-run]`** writes one ahead of its first call, or shows the diff.
+
+**Tested**
+- Offline tests run on Python 3.10–3.14 on Ubuntu, and on Windows, including the events and the `thunc watch` command. CI runs the dashboard's `cargo fmt`, `clippy` and tests on Linux, macOS and Windows, and on Linux builds the PyPI wheel and runs `thunc watch` from it.
+- thunc write: 45 offline tests of the source editing and the writing, end to end against a scripted model, including CRLF files; live, `live_tests/test_writing.py` on Codex wrote a function whose doctests pass.
+- `watch/demo/demo_app.py` runs the support-inbox functions and an agent against a scripted backend, with delays and bad replies, and makes no model calls.
+
+**Behavior changes**
+- None. `thunc watch`, `THUNC_EVENTS` and `write=` are new; nothing is written unless `THUNC_EVENTS` is set, and no file is edited unless a function has `write=True`. Nothing is removed.
+
+**Known issues:** the dashboard only watches: it can't stop a single agent run or approve `ask:` actions yet. `--agents` sees one folder, not every project on the machine. On Windows, Ctrl+C and quitting end the program at once, without the `KeyboardInterrupt` it gets on macOS and Linux. thunc write's checks are only as good as the model's answers, so review the code it writes; `thunc write` can't write methods ahead of their first call, and it doesn't run on `jev`. The full list is in [CONTRIBUTING.md](https://github.com/Eltarras/thunc/blob/main/CONTRIBUTING.md#known-issues), and every change is in [CHANGELOG.md](https://github.com/Eltarras/thunc/blob/main/CHANGELOG.md).
+
+**Full changelog:** https://github.com/Eltarras/thunc/compare/v0.2.3...v0.3.0

{thunc-0.2.2 → thunc-0.3.0}/.github/workflows/ci.yml

@@ -36,6 +36,32 @@ jobs:
         env:
           PYTHONIOENCODING: utf-8  # the console's own code page can't print every test id and message
 
+  # thunc-watch, the terminal dashboard: a Rust crate in watch/, separate from the Python package.
+  watch:
+    strategy:
+      fail-fast: false  # each platform reports its own result
+      matrix:
+        os: [ubuntu-latest, macos-latest, windows-latest]
+    runs-on: ${{ matrix.os }}
+    defaults:
+      run:
+        working-directory: watch
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          components: rustfmt, clippy
+      - run: cargo fmt --check
+      - run: cargo clippy --all-targets --locked -- -D warnings
+      - run: cargo test --locked
+      - name: The PyPI wheel builds and runs
+        if: matrix.os == 'ubuntu-latest'
+        run: |
+          pipx run maturin build --release --locked --out dist
+          python -m venv /tmp/wheel-check
+          /tmp/wheel-check/bin/pip install --quiet dist/*.whl ..
+          /tmp/wheel-check/bin/thunc watch --version
+
   temporal-integration:
     runs-on: ubuntu-latest
     strategy:

thunc-0.3.0/.github/workflows/publish-watch.yml

@@ -0,0 +1,81 @@
+name: Publish thunc-watch to PyPI
+
+# Runs when you publish a GitHub release tagged watch-vX.Y.Z (thunc's own vX.Y.Z releases are
+# publish.yml's). Builds the dashboard's wheels for each platform and publishes them as the
+# thunc-watch package, with PyPI Trusted Publishing: no API token is stored anywhere.
+
+on:
+  release:
+    types: [published]
+
+jobs:
+  version:
+    if: startsWith(github.event.release.tag_name, 'watch-v')
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: The tag matches watch/Cargo.toml
+        env:
+          TAG: ${{ github.event.release.tag_name }}
+        run: |
+          version=$(grep -m1 '^version' watch/Cargo.toml | cut -d'"' -f2)
+          if [ "${TAG#watch-v}" != "$version" ]; then
+            echo "The tag is $TAG but watch/Cargo.toml says $version" >&2
+            exit 1
+          fi
+
+  wheels:
+    needs: version
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - { os: ubuntu-latest, target: x86_64, manylinux: auto }
+          - { os: ubuntu-latest, target: aarch64, manylinux: auto }
+          - { os: ubuntu-latest, target: x86_64, manylinux: musllinux_1_2 }
+          - { os: ubuntu-latest, target: aarch64, manylinux: musllinux_1_2 }
+          - { os: macos-latest, target: aarch64, manylinux: "" }
+          - { os: macos-latest, target: x86_64, manylinux: "" }
+          - { os: windows-latest, target: x64, manylinux: "" }
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v4
+      - uses: PyO3/maturin-action@v1
+        with:
+          working-directory: watch
+          target: ${{ matrix.target }}
+          manylinux: ${{ matrix.manylinux || 'auto' }}
+          args: --release --locked --out dist
+      - uses: actions/upload-artifact@v4
+        with:
+          name: wheels-${{ matrix.os }}-${{ matrix.target }}-${{ matrix.manylinux }}
+          path: watch/dist
+
+  sdist:
+    needs: version
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: PyO3/maturin-action@v1
+        with:
+          working-directory: watch
+          command: sdist
+          args: --out dist
+      - uses: actions/upload-artifact@v4
+        with:
+          name: wheels-sdist
+          path: watch/dist
+
+  publish:
+    needs: [wheels, sdist]
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write   # lets PyPI verify this workflow; required for Trusted Publishing
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          pattern: wheels-*
+          merge-multiple: true
+          path: dist/
+      - uses: pypa/gh-action-pypi-publish@release/v1

{thunc-0.2.2 → thunc-0.3.0}/.github/workflows/publish.yml

@@ -2,6 +2,7 @@ name: Publish to PyPI
 
 # Runs when you publish a GitHub release (e.g. tag v0.1.0). Uses PyPI Trusted Publishing:
 # no API token is stored anywhere; PyPI trusts this workflow in this repo.
+# Releases tagged watch-vX.Y.Z are the dashboard's, published by publish-watch.yml instead.
 
 on:
   release:
@@ -9,6 +10,7 @@ on:
 
 jobs:
   build:
+    if: ${{ !startsWith(github.event.release.tag_name, 'watch-v') }}
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4

thunc-0.3.0/.github/workflows/release-notes.yml

@@ -0,0 +1,46 @@
+name: Release notes
+
+# Run by hand (Actions > Release notes > Run workflow) with a version like 0.2.2. It writes the
+# notes in .github/release-notes/v<version>.md to that release, and sets its title to
+# "v<version> (beta)". A release that doesn't exist yet is created as a draft pre-release on the
+# commit the workflow runs from, for you to review and publish. Editing or drafting a release
+# doesn't trigger publish.yml, which runs only when you publish one.
+
+on:
+  workflow_dispatch:
+    inputs:
+      version:
+        description: "Version, like 0.2.2"
+        required: true
+
+permissions:
+  contents: write  # create and edit releases
+
+jobs:
+  notes:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Write the notes to the release
+        env:
+          GH_TOKEN: ${{ github.token }}
+          VERSION: ${{ inputs.version }}
+        run: |
+          if [[ ! "$VERSION" =~ ^[0-9]+\.[0-9]+\.[0-9]+$ ]]; then
+            echo "::error::version must look like 0.2.2, not '$VERSION'"
+            exit 1
+          fi
+          tag="v$VERSION"
+          notes=".github/release-notes/$tag.md"
+          if [[ ! -f "$notes" ]]; then
+            echo "::error::$notes doesn't exist; add it first"
+            exit 1
+          fi
+          if gh release view "$tag" > /dev/null 2>&1; then
+            gh release edit "$tag" --title "$tag (beta)" --notes-file "$notes"
+            echo "Updated the notes of $tag."
+          else
+            gh release create "$tag" --draft --prerelease --target "$GITHUB_SHA" \
+              --title "$tag (beta)" --notes-file "$notes"
+            echo "Created $tag as a draft pre-release."
+          fi

{thunc-0.2.2 → thunc-0.3.0}/.gitignore

@@ -13,3 +13,5 @@ dist/
 .temporal-dev/
 examples/temporal/temporal-state/
 examples/temporal/temporal-workspace/
+watch/target/
+watch/dist/