reclaude 0.1.0__tar.gz

reclaude-0.1.0/.github/workflows/publish.yml

@@ -0,0 +1,26 @@
+name: publish
+
+on:
+  push:
+    tags:
+      - "v*"
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v5
+      - run: uv run --group dev pytest -q
+
+  publish:
+    needs: test
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v5
+      - run: uv build
+      - uses: pypa/gh-action-pypi-publish@release/v1

reclaude-0.1.0/.gitignore

@@ -0,0 +1,4 @@
+__pycache__/
+*.pyc
+.pytest_cache/
+dist/

reclaude-0.1.0/CLAUDE.md

@@ -0,0 +1,51 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## What this is
+
+`reclaude` is a stdlib-only Python curses picker for resuming Claude Code sessions. It reads `~/.claude/history.jsonl`, shows recent project directories as an expandable tree (sessions inline), locks directories that already have a running claude session, can resurrect sessions from deleted git worktrees, then chdirs and execs `claude`. Packaged for PyPI; installed with `uv tool install reclaude` (or `uv tool install --editable .` for hacking), which puts the `reclaude` console script on `PATH`.
+
+## Commands
+
+```bash
+python3 -m pytest -q                                   # run all tests (from repo root)
+python3 -m pytest tests/test_reclaude.py::test_mung_path -v   # single test
+uv run --group dev pytest -q                            # tests in an isolated env (as CI does)
+uv build                                                # build sdist + wheel into dist/
+reclaude                                                # run (needs a real TTY)
+```
+
+No third-party runtime dependencies (Python 3.10+ stdlib; pytest for tests). `[tool.pytest.ini_options] pythonpath = ["src"]` in `pyproject.toml` lets `python3 -m pytest` import the package from the repo root without an install. Releases publish to PyPI via `.github/workflows/publish.yml` (trusted publishing) on a `v*` tag push.
+
+## Architecture
+
+`reclaude` is a `src/` package (`src/reclaude/`): `__init__.py` holds all the logic, deliberately split into two halves (it can be broken into separate modules — e.g. pure `core.py` + curses `tui.py` — without touching packaging); `__main__.py` wires up `python -m reclaude`. The two halves of `__init__.py`:
+
+1. **Pure functions (top half, unit-tested):** `parse_history` → `group_by_home` builds per-directory groups of sessions; `classify_dir` tags each dir live / orphan-worktree / gone; `live_sessions` finds busy dirs + running session ids; `flatten_rows` turns groups + UI state (expansion, typed filter, age window, missing toggle) into the visible row list; `_row_spans` renders a row as `(text, colorkey)` spans. All filesystem/proc access is injectable (`isdir=`, `transcript_exists=`, `proc_root=`, `sessions_dir=`) so tests are hermetic — keep it that way.
+2. **Curses layer (bottom half, no unit tests):** `init_colors` maps colorkeys → curses attrs (monochrome fallback), `_draw` renders span rows, `run_picker` is the event loop returning a launch tuple, `main` execs claude. Verified via throwaway fake-stdscr harnesses (scripted `getch`, recorded `addnstr`) in /tmp — never committed — plus manual testing by Bryce.
+
+Data flow: `history.jsonl` → entries → groups (sessions attributed to their **home** dir) → rows → spans → screen; picker returns `("resume", path, id)` or `("worktree", repo, name, id)` → `os.chdir` + `os.execvp`.
+
+### Invariants worth protecting
+
+- **Display = action.** A dir row shows the time/prompt of `vis_sessions[0]` and Enter resumes exactly that session id. Never reintroduce `claude --continue` — it can disagree with what's displayed.
+- **Filters before the MAX_DIRS cap** in `flatten_rows`, so hiding noise surfaces older live dirs.
+- **Printable keys feed the incremental filter.** New shortcuts must be control keys (Ctrl-W=23 toggles missing dirs, Ctrl-T=20 cycles the age window); `q` quits only when the filter is empty.
+- `COLOR_KEYS` must cover every key `_row_spans` emits.
+- All `addnstr` calls write at most `maxx - 1` columns and are wrapped in `try/except curses.error` (tiny terminals, bottom-right quirk).
+
+## Empirically verified Claude Code facts (the whole design rests on these)
+
+- `claude --resume <id>` / `--continue` only find transcripts under `~/.claude/projects/<munged-cwd>/` for the **current** directory. Munging: `/` and `.` → `-` (deterministic; un-munging is ambiguous — only ever mung).
+- A session's transcript lives under the directory the session **started** in and never moves, even if the session later changed cwd (EnterWorktree etc.). Hence `group_by_home`: first project in history = the only resumable location.
+- Deleted worktree sessions resurrect via `cd <repo> && claude --worktree <name> --resume <id>` — claude recreates `<repo>/.claude/worktrees/<name>` (branch `worktree-<name>`, base per `worktree.baseRef`) and finds the transcript because the path matches again.
+- `~/.claude/sessions/<pid>.json` describes live claude processes (`{pid, sessionId, cwd, ...}`). Stale files survive crashes — always validate `/proc/<pid>/comm == "claude"` before trusting one.
+- `history.jsonl` lines: `{"display", "pastedContents", "timestamp"(ms), "project", "sessionId"}`; `display` can contain newlines/tabs (flattened in `parse_history`).
+
+If claude changes any of this, re-verify empirically (cheap probe: `claude --resume <id> --fork-session --model haiku --print "Reply with only the word ok"` from the directory under test; clean up the forked transcript afterwards).
+
+## Workflow conventions
+
+- TDD for pure functions; the curses layer changes get fake-stdscr smoke tests instead.
+- Commits are conventional-commit style (`feat:`, `fix:`, `chore:`, `polish:`). No standalone `docs:` or `test:` commits — documentation and test changes ride along in the feature or bugfix commit they belong to.

reclaude-0.1.0/LICENSE

@@ -0,0 +1,24 @@
+BSD 2-Clause License
+
+Copyright (c) 2026 Bryce Boe
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

reclaude-0.1.0/PKG-INFO

@@ -0,0 +1,72 @@
+Metadata-Version: 2.4
+Name: reclaude
+Version: 0.1.0
+Summary: Curses picker for resuming Claude Code sessions
+Project-URL: Homepage, https://github.com/bboe/reclaude
+Project-URL: Repository, https://github.com/bboe/reclaude
+Project-URL: Issues, https://github.com/bboe/reclaude/issues
+Author-email: Bryce Boe <bbzbryce@gmail.com>
+License-Expression: BSD-2-Clause
+License-File: LICENSE
+Keywords: claude,claude-code,curses,resume,tui
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console :: Curses
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: POSIX
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Utilities
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# reclaude
+
+A keyboard-driven curses picker for resuming [Claude Code](https://claude.com/claude-code)
+sessions. It reads `~/.claude/history.jsonl` and shows your recent project directories as an
+expandable tree with sessions inline, so you can jump back into a conversation without
+remembering its session id.
+
+- **Tree view** of recent directories; expand one to see its individual sessions, each shown
+  with its time and opening prompt.
+- **Live-session locks** — directories with a running `claude` process are marked so you don't
+  collide with an active session.
+- **Worktree resurrection** — sessions from deleted git worktrees can be brought back; reclaude
+  re-runs them via `claude --worktree`, which recreates the worktree and finds the transcript.
+- On selection it `chdir`s into the directory and `exec`s `claude --resume <id>` (display always
+  matches the action — the row you see is the session you get).
+
+## Install
+
+```bash
+uv tool install reclaude     # recommended
+pipx install reclaude
+pip install reclaude
+```
+
+## Usage
+
+```bash
+reclaude          # or: python -m reclaude
+```
+
+| Key            | Action                                            |
+| -------------- | ------------------------------------------------- |
+| `↑` / `↓`      | Move selection                                    |
+| `Enter`        | Expand a directory, or resume the selected session |
+| *type*         | Incrementally filter by directory / prompt text   |
+| `Ctrl-W`       | Toggle showing directories whose path is gone     |
+| `Ctrl-T`       | Cycle the age window (how far back to look)        |
+| `Backspace`    | Delete a filter character                         |
+| `q` / `Esc`    | Quit (`q` quits only when the filter is empty)    |
+
+## Requirements
+
+- A POSIX system with an interactive terminal (TTY).
+- [Claude Code](https://claude.com/claude-code) installed and on your `PATH`.
+- Python 3.10+. No third-party dependencies (Python standard library only).
+
+## License
+
+BSD-2-Clause. See [LICENSE](LICENSE).

reclaude-0.1.0/README.md

@@ -0,0 +1,49 @@
+# reclaude
+
+A keyboard-driven curses picker for resuming [Claude Code](https://claude.com/claude-code)
+sessions. It reads `~/.claude/history.jsonl` and shows your recent project directories as an
+expandable tree with sessions inline, so you can jump back into a conversation without
+remembering its session id.
+
+- **Tree view** of recent directories; expand one to see its individual sessions, each shown
+  with its time and opening prompt.
+- **Live-session locks** — directories with a running `claude` process are marked so you don't
+  collide with an active session.
+- **Worktree resurrection** — sessions from deleted git worktrees can be brought back; reclaude
+  re-runs them via `claude --worktree`, which recreates the worktree and finds the transcript.
+- On selection it `chdir`s into the directory and `exec`s `claude --resume <id>` (display always
+  matches the action — the row you see is the session you get).
+
+## Install
+
+```bash
+uv tool install reclaude     # recommended
+pipx install reclaude
+pip install reclaude
+```
+
+## Usage
+
+```bash
+reclaude          # or: python -m reclaude
+```
+
+| Key            | Action                                            |
+| -------------- | ------------------------------------------------- |
+| `↑` / `↓`      | Move selection                                    |
+| `Enter`        | Expand a directory, or resume the selected session |
+| *type*         | Incrementally filter by directory / prompt text   |
+| `Ctrl-W`       | Toggle showing directories whose path is gone     |
+| `Ctrl-T`       | Cycle the age window (how far back to look)        |
+| `Backspace`    | Delete a filter character                         |
+| `q` / `Esc`    | Quit (`q` quits only when the filter is empty)    |
+
+## Requirements
+
+- A POSIX system with an interactive terminal (TTY).
+- [Claude Code](https://claude.com/claude-code) installed and on your `PATH`.
+- Python 3.10+. No third-party dependencies (Python standard library only).
+
+## License
+
+BSD-2-Clause. See [LICENSE](LICENSE).

reclaude-0.1.0/pyproject.toml

@@ -0,0 +1,42 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "reclaude"
+version = "0.1.0"
+description = "Curses picker for resuming Claude Code sessions"
+readme = "README.md"
+requires-python = ">=3.10"
+license = "BSD-2-Clause"
+license-files = ["LICENSE"]
+authors = [{ name = "Bryce Boe", email = "bbzbryce@gmail.com" }]
+keywords = ["claude", "claude-code", "curses", "tui", "resume"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Environment :: Console :: Curses",
+    "Intended Audience :: Developers",
+    "Operating System :: POSIX",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Utilities",
+]
+
+[project.urls]
+Homepage = "https://github.com/bboe/reclaude"
+Repository = "https://github.com/bboe/reclaude"
+Issues = "https://github.com/bboe/reclaude/issues"
+
+[project.scripts]
+reclaude = "reclaude:main"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/reclaude"]
+
+[dependency-groups]
+dev = ["pytest"]
+
+[tool.pytest.ini_options]
+pythonpath = ["src"]

reclaude-0.1.0/src/reclaude/__init__.py

@@ -0,0 +1,476 @@
+"""reclaude: curses picker for recent Claude Code sessions.
+
+Reads ~/.claude/history.jsonl, shows recent project directories as an
+expandable tree (sessions inline under each directory), marks directories
+with a running claude session as locked, resurrects sessions from deleted
+git worktrees via `claude --worktree`, then chdirs and execs claude.
+"""
+import curses
+import json
+import os
+import re
+import sys
+import time
+
+HISTORY_PATH = os.path.expanduser("~/.claude/history.jsonl")
+MAX_DIRS = 30
+PROJECTS_DIR = os.path.expanduser("~/.claude/projects")
+SESSIONS_DIR = os.path.expanduser("~/.claude/sessions")
+
+
+def parse_history(lines):
+    """Parse history.jsonl lines into entry dicts, skipping malformed lines."""
+    entries = []
+    for line in lines:
+        try:
+            obj = json.loads(line)
+        except (json.JSONDecodeError, ValueError):
+            continue
+        if not isinstance(obj, dict):
+            continue
+        project = obj.get("project")
+        session_id = obj.get("sessionId")
+        ts = obj.get("timestamp")
+        display = obj.get("display")
+        if not (isinstance(project, str) and isinstance(session_id, str)
+                and isinstance(ts, (int, float)) and not isinstance(ts, bool)):
+            continue
+        if isinstance(display, str):
+            display = " ".join(display.split())
+        else:
+            display = ""
+        entries.append({
+            "project": project,
+            "session_id": session_id,
+            "ts": ts,
+            "display": display,
+        })
+    return entries
+
+
+def mung_path(path):
+    """Munged ~/.claude/projects dir name for a path: '/' and '.' become '-'."""
+    return path.replace("/", "-").replace(".", "-")
+
+
+def transcript_path(home_dir, session_id, projects_dir=None):
+    return os.path.join(projects_dir or PROJECTS_DIR,
+                        mung_path(home_dir), session_id + ".jsonl")
+
+
+def transcript_exists(home_dir, session_id, projects_dir=None):
+    return os.path.isfile(transcript_path(home_dir, session_id, projects_dir))
+
+
+def group_by_home(entries, transcript_exists=transcript_exists):
+    """Group sessions under their home dir (first project seen), newest first.
+
+    A session's transcript lives where the session started, so that first
+    directory is the only place `claude --resume` can find it. Sessions whose
+    transcript no longer exists are dropped. Each group:
+    {"path", "last_ts", "sessions": [{"session_id", "ts", "display"}, ...]}
+    with sessions newest-first.
+    """
+    sessions = {}
+    for e in entries:
+        s = sessions.setdefault(e["session_id"],
+                                {"home": e["project"], "ts": 0, "display": ""})
+        if e["ts"] >= s["ts"]:
+            s["ts"] = e["ts"]
+            s["display"] = e["display"]
+    dirs = {}
+    for sid, s in sessions.items():
+        if not transcript_exists(s["home"], sid):
+            continue
+        dirs.setdefault(s["home"], []).append(
+            {"session_id": sid, "ts": s["ts"], "display": s["display"]})
+    groups = []
+    for path, sess in dirs.items():
+        sess.sort(key=lambda s: -s["ts"])
+        groups.append({"path": path, "last_ts": sess[0]["ts"], "sessions": sess})
+    groups.sort(key=lambda g: -g["last_ts"])
+    return groups
+
+
+WORKTREE_RE = re.compile(r"^(?P<repo>.+)/\.claude/worktrees/(?P<name>[^/]+)$")
+
+
+def classify_dir(path, isdir=os.path.isdir):
+    """Classify a session home dir.
+
+    Returns (kind, repo, name): kind is "live" (dir exists), "orphan-worktree"
+    (dir gone but it was <repo>/.claude/worktrees/<name> and <repo> exists —
+    resumable via `claude --worktree <name> --resume <id>` from <repo>), or
+    "gone". repo/name are None unless kind == "orphan-worktree".
+    """
+    if isdir(path):
+        return ("live", None, None)
+    m = WORKTREE_RE.match(path)
+    if m and isdir(m.group("repo")):
+        return ("orphan-worktree", m.group("repo"), m.group("name"))
+    return ("gone", None, None)
+
+
+def find_busy_dirs(proc_root="/proc"):
+    """Return the set of realpath cwds of running `claude` processes."""
+    busy = set()
+    try:
+        names = os.listdir(proc_root)
+    except OSError:
+        return busy
+    for name in names:
+        if not name.isdigit():
+            continue
+        base = os.path.join(proc_root, name)
+        try:
+            with open(os.path.join(base, "comm")) as f:
+                if f.read().strip() != "claude":
+                    continue
+            busy.add(os.path.realpath(os.path.join(base, "cwd")))
+        except OSError:
+            continue  # process exited, or not ours to read
+    return busy
+
+
+def live_sessions(sessions_dir=None, proc_root="/proc"):
+    """Busy dirs and running session ids from ~/.claude/sessions records.
+
+    Each <pid>.json record counts only if /proc/<pid>/comm is "claude" (stale
+    files survive crashes). Falls back to scanning /proc when the records
+    yield nothing, so a claude started outside the session tracker still
+    locks its directory (running ids unknown in that case).
+    """
+    busy, running = set(), set()
+    try:
+        names = os.listdir(sessions_dir or SESSIONS_DIR)
+    except OSError:
+        names = []
+    for name in names:
+        if not name.endswith(".json"):
+            continue
+        try:
+            with open(os.path.join(sessions_dir or SESSIONS_DIR, name)) as f:
+                rec = json.load(f)
+        except (OSError, ValueError):
+            continue
+        if not isinstance(rec, dict):
+            continue
+        pid, cwd, sid = rec.get("pid"), rec.get("cwd"), rec.get("sessionId")
+        if not (isinstance(pid, int) and isinstance(cwd, str)):
+            continue
+        try:
+            with open(os.path.join(proc_root, str(pid), "comm")) as f:
+                if f.read().strip() != "claude":
+                    continue
+        except OSError:
+            continue
+        busy.add(os.path.realpath(cwd))
+        if isinstance(sid, str):
+            running.add(sid)
+    if not busy:
+        busy = find_busy_dirs(proc_root)
+    return busy, running
+
+
+def relative_time(ts_ms, now_ms):
+    """Compact age like '5s', '3m', '7h', '2d'."""
+    secs = max(0, int((now_ms - ts_ms) / 1000))
+    if secs < 60:
+        return f"{secs}s"
+    if secs < 3600:
+        return f"{secs // 60}m"
+    if secs < 86400:
+        return f"{secs // 3600}h"
+    return f"{secs // 86400}d"
+
+
+def abbreviate_path(path, home):
+    if path == home:
+        return "~"
+    if path.startswith(home + os.sep):
+        return "~" + path[len(home):]
+    return path
+
+
+def truncate(s, width):
+    if width <= 0:
+        return ""
+    if len(s) <= width:
+        return s
+    return s[: width - 1] + "…"
+
+
+def _is_busy(path, busy):
+    return os.path.realpath(path) in busy
+
+
+def flatten_rows(groups, expanded, filt, home, busy, running_ids,
+                 isdir=os.path.isdir, show_missing=True, min_ts=None):
+    """Flatten groups + expansion state into the visible row list.
+
+    Dir row:     {"kind": "dir", "group", "vis_sessions", "cls", "repo",
+                  "name", "busy"}
+    Session row: {"kind": "session", "group", "session", "cls", "repo",
+                  "name", "busy", "running"}.
+    A session is visible iff it passes the age window (min_ts) and the text
+    filter — a dir-path match admits all its sessions, otherwise the prompt
+    text must contain the filter (both case-insensitive). A dir is shown iff
+    it has visible sessions and passes the missing-dir filter; dirs are
+    capped at MAX_DIRS. Expanded dirs render only their visible sessions.
+    """
+    f = filt.lower()
+    kept = []
+    for g in groups:
+        path_match = f in abbreviate_path(g["path"], home).lower()
+        vis = [s for s in g["sessions"]
+               if (min_ts is None or s["ts"] >= min_ts)
+               and (path_match or f in s["display"].lower())]
+        if not vis:
+            continue
+        cls, repo, name = classify_dir(g["path"], isdir)
+        if not show_missing and cls != "live":
+            continue
+        kept.append((g, vis, cls, repo, name))
+    rows = []
+    for g, vis, cls, repo, name in kept[:MAX_DIRS]:
+        b = _is_busy(g["path"], busy)
+        rows.append({"kind": "dir", "group": g, "vis_sessions": vis,
+                     "cls": cls, "repo": repo, "name": name, "busy": b})
+        if g["path"] in expanded:
+            for s in vis:
+                rows.append({"kind": "session", "group": g, "session": s,
+                             "cls": cls, "repo": repo, "name": name, "busy": b,
+                             "running": s["session_id"] in running_ids})
+    return rows
+
+
+# COLOR_KEYS must cover every key that _row_spans emits.
+COLOR_KEYS = ("time", "path", "running", "orphan", "gone", "flash", "text")
+
+
+def init_colors():
+    """Map color keys to curses attributes; monochrome fallback."""
+    attrs = {k: curses.A_NORMAL for k in COLOR_KEYS}
+    attrs["path"] = curses.A_BOLD
+    attrs["gone"] = curses.A_DIM
+    try:
+        curses.start_color()
+        curses.use_default_colors()
+        if not curses.has_colors():
+            return attrs
+        for i, (key, color) in enumerate([
+                ("time", curses.COLOR_CYAN),
+                ("running", curses.COLOR_YELLOW),
+                ("orphan", curses.COLOR_MAGENTA),
+                ("flash", curses.COLOR_RED)], start=1):
+            curses.init_pair(i, color, -1)
+            attrs[key] = curses.color_pair(i)
+    except curses.error:
+        pass
+    return attrs
+
+
+def _draw(stdscr, title, render_rows, sel, top, footer, footer_attr, attrs):
+    """render_rows: list of (spans, extra_attr). Returns new scroll `top`."""
+    stdscr.erase()
+    maxy, maxx = stdscr.getmaxyx()
+    # maxy==1: header only; maxy==2: header (y=0) + footer (y=1), no body rows.
+    body = max(0, maxy - 2)
+    if sel < top:
+        top = sel
+    elif body > 0 and sel >= top + body:
+        top = sel - body + 1
+    try:
+        stdscr.addnstr(0, 0, truncate(title, maxx - 1), maxx - 1, curses.A_BOLD)
+    except curses.error:
+        pass
+    for i, (spans, extra) in enumerate(render_rows[top:top + body]):
+        row_attr = extra | (curses.A_REVERSE if top + i == sel else 0)
+        x = 0
+        for text, key in spans:
+            avail = maxx - 1 - x
+            if avail <= 0:
+                break
+            t = truncate(text, avail)
+            try:
+                stdscr.addnstr(1 + i, x, t, avail, attrs.get(key, curses.A_NORMAL) | row_attr)
+            except curses.error:
+                pass
+            x += len(t)
+        if x < maxx - 1:  # pad so the selection bar spans the line
+            try:
+                stdscr.addnstr(1 + i, x, " " * (maxx - 1 - x), maxx - 1 - x,
+                               row_attr)
+            except curses.error:
+                pass
+    if maxy >= 2:
+        try:
+            stdscr.addnstr(maxy - 1, 0, truncate(footer, maxx - 1), maxx - 1,
+                           footer_attr)
+        except curses.error:
+            pass
+    stdscr.refresh()
+    return top
+
+
+def _row_spans(row, now_ms, home):
+    """Render a flatten_rows row as [(text, colorkey)] spans.
+
+    Color keys: "time", "path", "running", "orphan", "gone", "text" — mapped
+    to curses attributes by init_colors().
+    """
+    if row["kind"] == "dir":
+        g = row["group"]
+        vis = row["vis_sessions"]
+        ts = vis[0]["ts"] if vis else g["last_ts"]
+        spans = [(f"{relative_time(ts, now_ms):>4}  ", "time"),
+                 (abbreviate_path(g["path"], home), "path")]
+        if row["busy"]:
+            spans.append((" [running]", "running"))
+        if row["cls"] == "orphan-worktree":
+            spans.append((" [worktree gone]", "orphan"))
+        elif row["cls"] == "gone":
+            spans.append((" [gone]", "gone"))
+        last = row["vis_sessions"][0]["display"] if row["vis_sessions"] else ""
+        if last:
+            spans.append((f"  —  {last}", "text"))
+        return spans
+    s = row["session"]
+    spans = [("    ", "text"),
+             (f"{relative_time(s['ts'], now_ms):>4}  ", "time"),
+             (s["display"] or "(no prompt)", "text")]
+    if row.get("running"):
+        spans.append((" [running]", "running"))
+    return spans
+
+
+AGE_WINDOWS = [("all", None), ("1mo", 30 * 86400_000), ("1w", 7 * 86400_000),
+               ("1d", 86400_000), ("1h", 3600_000)]
+HELP = ("↑↓ move · ⏎ resume · →/⇥ expand · ← collapse · ^W missing · "
+        "^T age · type to filter · q quit")
+FLASH_BUSY = "that directory already has a claude session running"
+FLASH_GONE = "directory no longer exists"
+
+
+def _launch(row, session_id):
+    if row["cls"] == "orphan-worktree":
+        return ("worktree", row["repo"], row["name"], session_id)
+    return ("resume", row["group"]["path"], session_id)
+
+
+def run_picker(stdscr, groups, busy, running_ids):
+    """Returns ('resume', path, id) | ('worktree', repo, name, id) | None."""
+    try:
+        curses.curs_set(0)
+    except curses.error:
+        pass
+    stdscr.keypad(True)
+    attrs = init_colors()
+    home = os.path.expanduser("~")
+
+    sel, top, filt, flash = 0, 0, "", ""
+    show_missing, age_idx = True, 0
+    expanded = set()
+
+    while True:
+        now_ms = int(time.time() * 1000)
+        label, window = AGE_WINDOWS[age_idx]
+        min_ts = now_ms - window if window is not None else None
+        rows = flatten_rows(groups, expanded, filt, home, busy, running_ids,
+                            show_missing=show_missing, min_ts=min_ts)
+        render = [(_row_spans(r, now_ms, home),
+                    curses.A_DIM if (r["busy"] or r["cls"] == "gone") else 0)
+                  for r in rows]
+        if flash:
+            footer, footer_attr, flash = flash, attrs["flash"], ""
+        elif filt:
+            footer, footer_attr = f"filter: {filt}▏", curses.A_DIM
+        else:
+            footer, footer_attr = HELP, curses.A_DIM
+        n = len(rows)
+        sel = max(0, min(sel, n - 1)) if n else 0
+        title = "reclaude — recent sessions"
+        if window is not None:
+            title += f" · ≤{label}"
+        if not show_missing:
+            title += " · missing hidden"
+        top = _draw(stdscr, title, render, sel, top, footer, footer_attr, attrs)
+
+        key = stdscr.getch()
+        if key == curses.KEY_UP:
+            sel = max(0, sel - 1)
+        elif key == curses.KEY_DOWN:
+            sel = min(n - 1, sel + 1) if n else 0
+        elif key in (curses.KEY_ENTER, 10, 13) and n:
+            r = rows[sel]
+            if r["busy"]:
+                flash = FLASH_BUSY
+            elif r["cls"] == "gone":
+                flash = FLASH_GONE
+            elif r["kind"] == "session":
+                return _launch(r, r["session"]["session_id"])
+            else:
+                return _launch(r, r["vis_sessions"][0]["session_id"])
+        elif key in (curses.KEY_RIGHT, ord("\t")) and n:
+            if rows[sel]["kind"] == "dir":
+                expanded.add(rows[sel]["group"]["path"])
+        elif key == curses.KEY_LEFT and n:
+            r = rows[sel]
+            if r["kind"] == "session":
+                for i in range(sel - 1, -1, -1):
+                    if rows[i]["kind"] == "dir" and rows[i]["group"] is r["group"]:
+                        sel = i
+                        break
+            else:
+                expanded.discard(r["group"]["path"])
+        elif key == 27:  # Esc
+            if filt:
+                filt, sel, top = "", 0, 0
+            else:
+                return None
+        elif key in (curses.KEY_BACKSPACE, 127, 8):
+            if filt:
+                filt, sel, top = filt[:-1], 0, 0
+        elif key == 23:  # Ctrl-W: toggle missing dirs
+            show_missing = not show_missing
+            sel, top = 0, 0
+        elif key == 20:  # Ctrl-T: cycle age filter
+            age_idx = (age_idx + 1) % len(AGE_WINDOWS)
+            sel, top = 0, 0
+        elif 32 <= key < 127:
+            ch = chr(key)
+            if ch == "q" and not filt:
+                return None
+            filt, sel, top = filt + ch, 0, 0
+
+
+def main():
+    try:
+        with open(HISTORY_PATH, encoding="utf-8") as f:
+            entries = parse_history(f)
+    except OSError as e:
+        sys.exit(f"reclaude: cannot read {HISTORY_PATH}: {e}")
+    groups = group_by_home(entries)
+    if not groups:
+        sys.exit("reclaude: no resumable sessions found in history")
+    busy, running_ids = live_sessions()
+    if not sys.stdout.isatty():
+        sys.exit("reclaude: needs an interactive terminal")
+    os.environ.setdefault("ESCDELAY", "25")
+    result = curses.wrapper(run_picker, groups, busy, running_ids)
+    if result is None:
+        return
+    if result[0] == "worktree":
+        _, path, name, session_id = result
+        argv = ["claude", "--worktree", name, "--resume", session_id]
+    else:
+        _, path, session_id = result
+        argv = ["claude", "--resume", session_id]
+    try:
+        os.chdir(path)
+    except OSError as e:
+        sys.exit(f"reclaude: cannot chdir to {path}: {e}")
+    try:
+        os.execvp("claude", argv)
+    except OSError as e:
+        sys.exit(f"reclaude: cannot exec claude: {e}")

reclaude-0.1.0/src/reclaude/__main__.py

@@ -0,0 +1,4 @@
+from reclaude import main
+
+if __name__ == "__main__":
+    main()

reclaude-0.1.0/tests/test_reclaude.py

@@ -0,0 +1,300 @@
+import json
+import os
+
+import reclaude as cr
+
+
+def test_parse_history_basic():
+    lines = [
+        '{"display":"fix bug","pastedContents":{},"timestamp":1000,"project":"/p/a","sessionId":"s1"}',
+        '{"display":"add feat","timestamp":2000,"project":"/p/b","sessionId":"s2"}',
+    ]
+    entries = cr.parse_history(lines)
+    assert entries == [
+        {"project": "/p/a", "session_id": "s1", "ts": 1000, "display": "fix bug"},
+        {"project": "/p/b", "session_id": "s2", "ts": 2000, "display": "add feat"},
+    ]
+
+
+def test_parse_history_skips_garbage():
+    lines = [
+        "not json at all",
+        '{"display":"missing fields"}',
+        '"a json string, not an object"',
+        '{"display":null,"timestamp":3000,"project":"/p/c","sessionId":"s3"}',
+        "",
+    ]
+    entries = cr.parse_history(lines)
+    # Only the entry with all required fields survives; null display becomes ""
+    assert entries == [{"project": "/p/c", "session_id": "s3", "ts": 3000, "display": ""}]
+
+
+def _e(project, sid, ts, display=""):
+    return {"project": project, "session_id": sid, "ts": ts, "display": display}
+
+
+def test_group_by_home_attribution_and_order():
+    entries = [
+        _e("/p/a", "s1", 1000, "first"),
+        _e("/p/b", "s1", 5000, "moved"),   # session moved dirs: home stays /p/a
+        _e("/p/a", "s2", 3000, "second"),
+        _e("/p/c", "s3", 9000, "newest"),
+    ]
+    groups = cr.group_by_home(entries, transcript_exists=lambda h, s: True)
+    assert [g["path"] for g in groups] == ["/p/c", "/p/a"]
+    a = groups[1]
+    assert a["last_ts"] == 5000
+    assert [s["session_id"] for s in a["sessions"]] == ["s1", "s2"]
+    assert a["sessions"][0]["display"] == "moved"
+
+
+def test_group_by_home_drops_sessions_without_transcript():
+    entries = [_e("/p/a", "s1", 1000), _e("/p/a", "s2", 2000), _e("/p/b", "s3", 3000)]
+    groups = cr.group_by_home(entries, transcript_exists=lambda h, sid: sid != "s2")
+    assert [g["path"] for g in groups] == ["/p/b", "/p/a"]
+    assert [s["session_id"] for s in groups[1]["sessions"]] == ["s1"]
+
+
+def test_group_by_home_drops_empty_groups():
+    entries = [_e("/p/a", "s1", 1000)]
+    assert cr.group_by_home(entries, transcript_exists=lambda h, s: False) == []
+
+
+def _fake_proc(tmp_path, pid, comm, cwd_target):
+    p = tmp_path / str(pid)
+    p.mkdir()
+    (p / "comm").write_text(comm + "\n")
+    (p / "cwd").symlink_to(cwd_target)
+
+
+def test_find_busy_dirs(tmp_path):
+    work = tmp_path / "work"
+    work.mkdir()
+    other = tmp_path / "other"
+    other.mkdir()
+    _fake_proc(tmp_path, 100, "claude", work)
+    _fake_proc(tmp_path, 200, "vim", other)        # wrong comm: ignored
+    (tmp_path / "self").mkdir()                     # non-numeric entry: ignored
+    broken = tmp_path / "300"
+    broken.mkdir()                                  # numeric but no comm file: ignored
+    busy = cr.find_busy_dirs(proc_root=str(tmp_path))
+    assert busy == {os.path.realpath(str(work))}
+
+
+def test_find_busy_dirs_missing_proc_root():
+    assert cr.find_busy_dirs(proc_root="/nonexistent-proc") == set()
+
+
+def test_relative_time():
+    now = 10_000_000_000_000
+    assert cr.relative_time(now - 5_000, now) == "5s"
+    assert cr.relative_time(now - 90_000, now) == "1m"
+    assert cr.relative_time(now - 3 * 3600_000, now) == "3h"
+    assert cr.relative_time(now - 49 * 3600_000, now) == "2d"
+    assert cr.relative_time(now + 5_000, now) == "0s"  # clock skew clamps to 0
+
+
+def test_abbreviate_path():
+    assert cr.abbreviate_path("/home/u/proj", "/home/u") == "~/proj"
+    assert cr.abbreviate_path("/home/u", "/home/u") == "~"
+    assert cr.abbreviate_path("/home/uother/x", "/home/u") == "/home/uother/x"
+    assert cr.abbreviate_path("/etc/x", "/home/u") == "/etc/x"
+
+
+def test_parse_history_flattens_control_chars():
+    lines = ['{"display":"line one\\nline two\\tend","timestamp":1,"project":"/p","sessionId":"s"}']
+    assert cr.parse_history(lines)[0]["display"] == "line one line two end"
+
+
+def test_truncate():
+    assert cr.truncate("hello", 10) == "hello"
+    assert cr.truncate("hello world", 8) == "hello w…"
+    assert cr.truncate("hi", 0) == ""
+
+
+def test_mung_path():
+    assert cr.mung_path("/home/u/scratch") == "-home-u-scratch"
+    assert cr.mung_path("/home/u/repo/.claude/worktrees/a1") == \
+        "-home-u-repo--claude-worktrees-a1"
+
+
+def test_transcript_path():
+    p = cr.transcript_path("/home/u/scratch", "abc", projects_dir="/pp")
+    assert p == "/pp/-home-u-scratch/abc.jsonl"
+
+
+def test_transcript_exists(tmp_path):
+    d = tmp_path / "-home-u-x"
+    d.mkdir()
+    (d / "s1.jsonl").write_text("{}")
+    assert cr.transcript_exists("/home/u/x", "s1", projects_dir=str(tmp_path))
+    assert not cr.transcript_exists("/home/u/x", "s2", projects_dir=str(tmp_path))
+
+
+def test_classify_dir():
+    assert cr.classify_dir("/x", isdir=lambda p: True) == ("live", None, None)
+    assert cr.classify_dir("/r/.claude/worktrees/a1", isdir=lambda p: p == "/r") == \
+        ("orphan-worktree", "/r", "a1")
+    assert cr.classify_dir("/gone/dir", isdir=lambda p: False) == ("gone", None, None)
+
+
+def test_classify_dir_worktree_repo_also_gone():
+    assert cr.classify_dir("/r/.claude/worktrees/a1", isdir=lambda p: False) == \
+        ("gone", None, None)
+
+
+def _fake_session_file(dirpath, pid, sid, cwd):
+    (dirpath / f"{pid}.json").write_text(
+        json.dumps({"pid": pid, "sessionId": sid, "cwd": str(cwd)}))
+
+
+def test_live_sessions(tmp_path):
+    sdir = tmp_path / "sessions"
+    sdir.mkdir()
+    proc = tmp_path / "proc"
+    proc.mkdir()
+    work = tmp_path / "work"
+    work.mkdir()
+    _fake_session_file(sdir, 100, "s-live", work)          # live claude
+    p = proc / "100"
+    p.mkdir()
+    (p / "comm").write_text("claude\n")
+    _fake_session_file(sdir, 200, "s-stale", work)         # pid not running
+    _fake_session_file(sdir, 300, "s-vim", work)           # pid alive, not claude
+    p = proc / "300"
+    p.mkdir()
+    (p / "comm").write_text("vim\n")
+    (sdir / "400.json").write_text("not json")             # malformed
+    busy, running = cr.live_sessions(sessions_dir=str(sdir), proc_root=str(proc))
+    assert busy == {os.path.realpath(str(work))}
+    assert running == {"s-live"}
+
+
+def test_live_sessions_fallback_to_proc_scan(tmp_path):
+    proc = tmp_path / "proc"
+    proc.mkdir()
+    work = tmp_path / "work"
+    work.mkdir()
+    p = proc / "500"
+    p.mkdir()
+    (p / "comm").write_text("claude\n")
+    (p / "cwd").symlink_to(work)
+    busy, running = cr.live_sessions(sessions_dir=str(tmp_path / "missing"),
+                                     proc_root=str(proc))
+    assert busy == {os.path.realpath(str(work))}
+    assert running == set()
+
+
+def _g(path, sessions):
+    return {"path": path, "last_ts": sessions[0]["ts"], "sessions": sessions}
+
+
+def _s(sid, ts, display=""):
+    return {"session_id": sid, "ts": ts, "display": display}
+
+
+def test_flatten_rows_expansion_filter_running():
+    g1 = _g("/p/a", [_s("s1", 2000, "x"), _s("s2", 1000, "y")])
+    g2 = _g("/p/b", [_s("s3", 500, "z")])
+    rows = cr.flatten_rows([g1, g2], expanded={"/p/a"}, filt="", home="/h",
+                           busy=set(), running_ids={"s2"}, isdir=lambda p: True)
+    assert [(r["kind"], r.get("session", {}).get("session_id")) for r in rows] == [
+        ("dir", None), ("session", "s1"), ("session", "s2"), ("dir", None)]
+    assert rows[2]["running"] is True and rows[1]["running"] is False
+    rows = cr.flatten_rows([g1, g2], expanded={"/p/a"}, filt="B", home="/h",
+                           busy=set(), running_ids=set(), isdir=lambda p: True)
+    assert len(rows) == 1 and rows[0]["group"] is g2
+
+
+def test_flatten_rows_busy_and_classification():
+    g = _g("/r/.claude/worktrees/a1", [_s("s1", 100)])
+    rows = cr.flatten_rows([g], expanded={"/r/.claude/worktrees/a1"}, filt="",
+                           home="/h", busy={"/r/.claude/worktrees/a1"},
+                           running_ids=set(), isdir=lambda p: p == "/r")
+    assert rows[0]["cls"] == "orphan-worktree"
+    assert (rows[0]["repo"], rows[0]["name"]) == ("/r", "a1")
+    assert rows[0]["busy"] is True and rows[1]["busy"] is True
+
+
+def test_row_spans_dir():
+    g = _g("/h/proj", [_s("s1", 60_000, "newest"), _s("s0", 0, "older")])
+    row = {"kind": "dir", "group": g, "vis_sessions": g["sessions"][1:],
+           "cls": "live", "repo": None, "name": None, "busy": True}
+    # time and prompt come from the newest VISIBLE session (s0), not s1
+    assert cr._row_spans(row, now_ms=120_000, home="/h") == [
+        ("  2m  ", "time"), ("~/proj", "path"),
+        (" [running]", "running"), ("  —  older", "text")]
+
+
+def test_row_spans_badges_and_session():
+    g = _g("/r/.claude/worktrees/a1", [_s("s1", 0, "")])
+    row = {"kind": "dir", "group": g, "vis_sessions": g["sessions"], "cls": "orphan-worktree",
+           "repo": "/r", "name": "a1", "busy": False}
+    assert (" [worktree gone]", "orphan") in cr._row_spans(row, 0, "/h")
+    row["cls"] = "gone"
+    assert (" [gone]", "gone") in cr._row_spans(row, 0, "/h")
+    srow = {"kind": "session", "group": g, "session": _s("s1", 0, ""),
+            "cls": "live", "repo": None, "name": None, "busy": False,
+            "running": True}
+    assert cr._row_spans(srow, 0, "/h") == [
+        ("    ", "text"), ("  0s  ", "time"),
+        ("(no prompt)", "text"), (" [running]", "running")]
+
+
+def test_flatten_rows_show_missing_and_min_ts():
+    live = _g("/p/live", [_s("s1", 5000)])
+    orphan = _g("/r/.claude/worktrees/w1", [_s("s2", 4000)])
+    gone = _g("/gone/x", [_s("s3", 3000)])
+    isdir = lambda p: p in ("/p/live", "/r")
+    rows = cr.flatten_rows([live, orphan, gone], expanded=set(), filt="",
+                           home="/h", busy=set(), running_ids=set(),
+                           isdir=isdir, show_missing=False)
+    assert [r["group"] for r in rows] == [live]
+    rows = cr.flatten_rows([live, orphan, gone], expanded=set(), filt="",
+                           home="/h", busy=set(), running_ids=set(),
+                           isdir=isdir, min_ts=4000)
+    assert [r["group"] for r in rows] == [live, orphan]  # boundary ts kept
+
+
+def test_flatten_rows_filters_apply_before_cap():
+    gone_groups = [_g(f"/gone/{i}", [_s(f"g{i}", 10_000 - i)])
+                   for i in range(cr.MAX_DIRS)]
+    live_old = _g("/p/old", [_s("old", 1)])
+    rows = cr.flatten_rows(gone_groups + [live_old], expanded=set(), filt="",
+                           home="/h", busy=set(), running_ids=set(),
+                           isdir=lambda p: p == "/p/old", show_missing=False)
+    assert len(rows) == 1 and rows[0]["group"] is live_old
+
+
+def test_flatten_rows_prompt_text_match():
+    g1 = _g("/p/a", [_s("s1", 2000, "fix the parser"), _s("s2", 1000, "other")])
+    g2 = _g("/p/b", [_s("s3", 500, "unrelated")])
+    rows = cr.flatten_rows([g1, g2], expanded={"/p/a", "/p/b"}, filt="PARSER",
+                           home="/h", busy=set(), running_ids=set(),
+                           isdir=lambda p: True)
+    # dir surfaces on prompt match though its path doesn't match the filter;
+    # only the matching session renders; g2 is fully hidden
+    assert [(r["kind"], r.get("session", {}).get("session_id")) for r in rows] == [
+        ("dir", None), ("session", "s1")]
+    assert rows[0]["vis_sessions"] == [g1["sessions"][0]]
+
+
+def test_flatten_rows_age_filters_sessions_and_dir():
+    g = _g("/p/a", [_s("new", 5000, "recent"), _s("mid", 3000, "middle"),
+                    _s("old", 1000, "ancient")])
+    rows = cr.flatten_rows([g], expanded={"/p/a"}, filt="", home="/h",
+                           busy=set(), running_ids=set(), isdir=lambda p: True,
+                           min_ts=3000)
+    assert [r.get("session", {}).get("session_id") for r in rows] == [
+        None, "new", "mid"]                       # "old" hidden; boundary kept
+    assert rows[0]["vis_sessions"][0]["session_id"] == "new"
+    assert cr.flatten_rows([g], expanded=set(), filt="", home="/h",
+                           busy=set(), running_ids=set(), isdir=lambda p: True,
+                           min_ts=6000) == []     # no survivor -> dir hidden
+
+
+def test_flatten_rows_dir_top_reflects_filter():
+    g = _g("/p/a", [_s("s1", 2000, "alpha"), _s("s2", 1000, "beta")])
+    rows = cr.flatten_rows([g], expanded=set(), filt="beta", home="/h",
+                           busy=set(), running_ids=set(), isdir=lambda p: True)
+    assert rows[0]["vis_sessions"][0]["session_id"] == "s2"

reclaude-0.1.0/uv.lock

@@ -0,0 +1,156 @@
+version = 1
+revision = 3
+requires-python = ">=3.10"
+
+[[package]]
+name = "colorama"
+version = "0.4.6"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" },
+]
+
+[[package]]
+name = "exceptiongroup"
+version = "1.3.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/50/79/66800aadf48771f6b62f7eb014e352e5d06856655206165d775e675a02c9/exceptiongroup-1.3.1.tar.gz", hash = "sha256:8b412432c6055b0b7d14c310000ae93352ed6754f70fa8f7c34141f91c4e3219", size = 30371, upload-time = "2025-11-21T23:01:54.787Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/8a/0e/97c33bf5009bdbac74fd2beace167cab3f978feb69cc36f1ef79360d6c4e/exceptiongroup-1.3.1-py3-none-any.whl", hash = "sha256:a7a39a3bd276781e98394987d3a5701d0c4edffb633bb7a5144577f82c773598", size = 16740, upload-time = "2025-11-21T23:01:53.443Z" },
+]
+
+[[package]]
+name = "iniconfig"
+version = "2.3.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/72/34/14ca021ce8e5dfedc35312d08ba8bf51fdd999c576889fc2c24cb97f4f10/iniconfig-2.3.0.tar.gz", hash = "sha256:c76315c77db068650d49c5b56314774a7804df16fee4402c1f19d6d15d8c4730", size = 20503, upload-time = "2025-10-18T21:55:43.219Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/cb/b1/3846dd7f199d53cb17f49cba7e651e9ce294d8497c8c150530ed11865bb8/iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12", size = 7484, upload-time = "2025-10-18T21:55:41.639Z" },
+]
+
+[[package]]
+name = "packaging"
+version = "26.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d7/f1/e7a6dd94a8d4a5626c03e4e99c87f241ba9e350cd9e6d75123f992427270/packaging-26.2.tar.gz", hash = "sha256:ff452ff5a3e828ce110190feff1178bb1f2ea2281fa2075aadb987c2fb221661", size = 228134, upload-time = "2026-04-24T20:15:23.917Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/df/b2/87e62e8c3e2f4b32e5fe99e0b86d576da1312593b39f47d8ceef365e95ed/packaging-26.2-py3-none-any.whl", hash = "sha256:5fc45236b9446107ff2415ce77c807cee2862cb6fac22b8a73826d0693b0980e", size = 100195, upload-time = "2026-04-24T20:15:22.081Z" },
+]
+
+[[package]]
+name = "pluggy"
+version = "1.6.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f9/e2/3e91f31a7d2b083fe6ef3fa267035b518369d9511ffab804f839851d2779/pluggy-1.6.0.tar.gz", hash = "sha256:7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3", size = 69412, upload-time = "2025-05-15T12:30:07.975Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" },
+]
+
+[[package]]
+name = "pygments"
+version = "2.20.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/c3/b2/bc9c9196916376152d655522fdcebac55e66de6603a76a02bca1b6414f6c/pygments-2.20.0.tar.gz", hash = "sha256:6757cd03768053ff99f3039c1a36d6c0aa0b263438fcab17520b30a303a82b5f", size = 4955991, upload-time = "2026-03-29T13:29:33.898Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f4/7e/a72dd26f3b0f4f2bf1dd8923c85f7ceb43172af56d63c7383eb62b332364/pygments-2.20.0-py3-none-any.whl", hash = "sha256:81a9e26dd42fd28a23a2d169d86d7ac03b46e2f8b59ed4698fb4785f946d0176", size = 1231151, upload-time = "2026-03-29T13:29:30.038Z" },
+]
+
+[[package]]
+name = "pytest"
+version = "9.0.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+    { name = "exceptiongroup", marker = "python_full_version < '3.11'" },
+    { name = "iniconfig" },
+    { name = "packaging" },
+    { name = "pluggy" },
+    { name = "pygments" },
+    { name = "tomli", marker = "python_full_version < '3.11'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/7d/0d/549bd94f1a0a402dc8cf64563a117c0f3765662e2e668477624baeec44d5/pytest-9.0.3.tar.gz", hash = "sha256:b86ada508af81d19edeb213c681b1d48246c1a91d304c6c81a427674c17eb91c", size = 1572165, upload-time = "2026-04-07T17:16:18.027Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d4/24/a372aaf5c9b7208e7112038812994107bc65a84cd00e0354a88c2c77a617/pytest-9.0.3-py3-none-any.whl", hash = "sha256:2c5efc453d45394fdd706ade797c0a81091eccd1d6e4bccfcd476e2b8e0ab5d9", size = 375249, upload-time = "2026-04-07T17:16:16.13Z" },
+]
+
+[[package]]
+name = "reclaude"
+version = "0.1.0"
+source = { editable = "." }
+
+[package.dev-dependencies]
+dev = [
+    { name = "pytest" },
+]
+
+[package.metadata]
+
+[package.metadata.requires-dev]
+dev = [{ name = "pytest" }]
+
+[[package]]
+name = "tomli"
+version = "2.4.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/22/de/48c59722572767841493b26183a0d1cc411d54fd759c5607c4590b6563a6/tomli-2.4.1.tar.gz", hash = "sha256:7c7e1a961a0b2f2472c1ac5b69affa0ae1132c39adcb67aba98568702b9cc23f", size = 17543, upload-time = "2026-03-25T20:22:03.828Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f4/11/db3d5885d8528263d8adc260bb2d28ebf1270b96e98f0e0268d32b8d9900/tomli-2.4.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:f8f0fc26ec2cc2b965b7a3b87cd19c5c6b8c5e5f436b984e85f486d652285c30", size = 154704, upload-time = "2026-03-25T20:21:10.473Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/f7/675db52c7e46064a9aa928885a9b20f4124ecb9bc2e1ce74c9106648d202/tomli-2.4.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:4ab97e64ccda8756376892c53a72bd1f964e519c77236368527f758fbc36a53a", size = 149454, upload-time = "2026-03-25T20:21:12.036Z" },
+    { url = "https://files.pythonhosted.org/packages/61/71/81c50943cf953efa35bce7646caab3cf457a7d8c030b27cfb40d7235f9ee/tomli-2.4.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:96481a5786729fd470164b47cdb3e0e58062a496f455ee41b4403be77cb5a076", size = 237561, upload-time = "2026-03-25T20:21:13.098Z" },
+    { url = "https://files.pythonhosted.org/packages/48/c1/f41d9cb618acccca7df82aaf682f9b49013c9397212cb9f53219e3abac37/tomli-2.4.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5a881ab208c0baf688221f8cecc5401bd291d67e38a1ac884d6736cbcd8247e9", size = 243824, upload-time = "2026-03-25T20:21:14.569Z" },
+    { url = "https://files.pythonhosted.org/packages/22/e4/5a816ecdd1f8ca51fb756ef684b90f2780afc52fc67f987e3c61d800a46d/tomli-2.4.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:47149d5bd38761ac8be13a84864bf0b7b70bc051806bc3669ab1cbc56216b23c", size = 242227, upload-time = "2026-03-25T20:21:15.712Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/49/2b2a0ef529aa6eec245d25f0c703e020a73955ad7edf73e7f54ddc608aa5/tomli-2.4.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:ec9bfaf3ad2df51ace80688143a6a4ebc09a248f6ff781a9945e51937008fcbc", size = 247859, upload-time = "2026-03-25T20:21:17.001Z" },
+    { url = "https://files.pythonhosted.org/packages/83/bd/6c1a630eaca337e1e78c5903104f831bda934c426f9231429396ce3c3467/tomli-2.4.1-cp311-cp311-win32.whl", hash = "sha256:ff2983983d34813c1aeb0fa89091e76c3a22889ee83ab27c5eeb45100560c049", size = 97204, upload-time = "2026-03-25T20:21:18.079Z" },
+    { url = "https://files.pythonhosted.org/packages/42/59/71461df1a885647e10b6bb7802d0b8e66480c61f3f43079e0dcd315b3954/tomli-2.4.1-cp311-cp311-win_amd64.whl", hash = "sha256:5ee18d9ebdb417e384b58fe414e8d6af9f4e7a0ae761519fb50f721de398dd4e", size = 108084, upload-time = "2026-03-25T20:21:18.978Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/83/dceca96142499c069475b790e7913b1044c1a4337e700751f48ed723f883/tomli-2.4.1-cp311-cp311-win_arm64.whl", hash = "sha256:c2541745709bad0264b7d4705ad453b76ccd191e64aa6f0fc66b69a293a45ece", size = 95285, upload-time = "2026-03-25T20:21:20.309Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/ba/42f134a3fe2b370f555f44b1d72feebb94debcab01676bf918d0cb70e9aa/tomli-2.4.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:c742f741d58a28940ce01d58f0ab2ea3ced8b12402f162f4d534dfe18ba1cd6a", size = 155924, upload-time = "2026-03-25T20:21:21.626Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/c7/62d7a17c26487ade21c5422b646110f2162f1fcc95980ef7f63e73c68f14/tomli-2.4.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:7f86fd587c4ed9dd76f318225e7d9b29cfc5a9d43de44e5754db8d1128487085", size = 150018, upload-time = "2026-03-25T20:21:23.002Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/05/79d13d7c15f13bdef410bdd49a6485b1c37d28968314eabee452c22a7fda/tomli-2.4.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ff18e6a727ee0ab0388507b89d1bc6a22b138d1e2fa56d1ad494586d61d2eae9", size = 244948, upload-time = "2026-03-25T20:21:24.04Z" },
+    { url = "https://files.pythonhosted.org/packages/10/90/d62ce007a1c80d0b2c93e02cab211224756240884751b94ca72df8a875ca/tomli-2.4.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:136443dbd7e1dee43c68ac2694fde36b2849865fa258d39bf822c10e8068eac5", size = 253341, upload-time = "2026-03-25T20:21:25.177Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/7e/caf6496d60152ad4ed09282c1885cca4eea150bfd007da84aea07bcc0a3e/tomli-2.4.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:5e262d41726bc187e69af7825504c933b6794dc3fbd5945e41a79bb14c31f585", size = 248159, upload-time = "2026-03-25T20:21:26.364Z" },
+    { url = "https://files.pythonhosted.org/packages/99/e7/c6f69c3120de34bbd882c6fba7975f3d7a746e9218e56ab46a1bc4b42552/tomli-2.4.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:5cb41aa38891e073ee49d55fbc7839cfdb2bc0e600add13874d048c94aadddd1", size = 253290, upload-time = "2026-03-25T20:21:27.46Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/2f/4a3c322f22c5c66c4b836ec58211641a4067364f5dcdd7b974b4c5da300c/tomli-2.4.1-cp312-cp312-win32.whl", hash = "sha256:da25dc3563bff5965356133435b757a795a17b17d01dbc0f42fb32447ddfd917", size = 98141, upload-time = "2026-03-25T20:21:28.492Z" },
+    { url = "https://files.pythonhosted.org/packages/24/22/4daacd05391b92c55759d55eaee21e1dfaea86ce5c571f10083360adf534/tomli-2.4.1-cp312-cp312-win_amd64.whl", hash = "sha256:52c8ef851d9a240f11a88c003eacb03c31fc1c9c4ec64a99a0f922b93874fda9", size = 108847, upload-time = "2026-03-25T20:21:29.386Z" },
+    { url = "https://files.pythonhosted.org/packages/68/fd/70e768887666ddd9e9f5d85129e84910f2db2796f9096aa02b721a53098d/tomli-2.4.1-cp312-cp312-win_arm64.whl", hash = "sha256:f758f1b9299d059cc3f6546ae2af89670cb1c4d48ea29c3cacc4fe7de3058257", size = 95088, upload-time = "2026-03-25T20:21:30.677Z" },
+    { url = "https://files.pythonhosted.org/packages/07/06/b823a7e818c756d9a7123ba2cda7d07bc2dd32835648d1a7b7b7a05d848d/tomli-2.4.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:36d2bd2ad5fb9eaddba5226aa02c8ec3fa4f192631e347b3ed28186d43be6b54", size = 155866, upload-time = "2026-03-25T20:21:31.65Z" },
+    { url = "https://files.pythonhosted.org/packages/14/6f/12645cf7f08e1a20c7eb8c297c6f11d31c1b50f316a7e7e1e1de6e2e7b7e/tomli-2.4.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:eb0dc4e38e6a1fd579e5d50369aa2e10acfc9cace504579b2faabb478e76941a", size = 149887, upload-time = "2026-03-25T20:21:33.028Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/e0/90637574e5e7212c09099c67ad349b04ec4d6020324539297b634a0192b0/tomli-2.4.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c7f2c7f2b9ca6bdeef8f0fa897f8e05085923eb091721675170254cbc5b02897", size = 243704, upload-time = "2026-03-25T20:21:34.51Z" },
+    { url = "https://files.pythonhosted.org/packages/10/8f/d3ddb16c5a4befdf31a23307f72828686ab2096f068eaf56631e136c1fdd/tomli-2.4.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f3c6818a1a86dd6dca7ddcaaf76947d5ba31aecc28cb1b67009a5877c9a64f3f", size = 251628, upload-time = "2026-03-25T20:21:36.012Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/f1/dbeeb9116715abee2485bf0a12d07a8f31af94d71608c171c45f64c0469d/tomli-2.4.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:d312ef37c91508b0ab2cee7da26ec0b3ed2f03ce12bd87a588d771ae15dcf82d", size = 247180, upload-time = "2026-03-25T20:21:37.136Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/74/16336ffd19ed4da28a70959f92f506233bd7cfc2332b20bdb01591e8b1d1/tomli-2.4.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:51529d40e3ca50046d7606fa99ce3956a617f9b36380da3b7f0dd3dd28e68cb5", size = 251674, upload-time = "2026-03-25T20:21:38.298Z" },
+    { url = "https://files.pythonhosted.org/packages/16/f9/229fa3434c590ddf6c0aa9af64d3af4b752540686cace29e6281e3458469/tomli-2.4.1-cp313-cp313-win32.whl", hash = "sha256:2190f2e9dd7508d2a90ded5ed369255980a1bcdd58e52f7fe24b8162bf9fedbd", size = 97976, upload-time = "2026-03-25T20:21:39.316Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/1e/71dfd96bcc1c775420cb8befe7a9d35f2e5b1309798f009dca17b7708c1e/tomli-2.4.1-cp313-cp313-win_amd64.whl", hash = "sha256:8d65a2fbf9d2f8352685bc1364177ee3923d6baf5e7f43ea4959d7d8bc326a36", size = 108755, upload-time = "2026-03-25T20:21:40.248Z" },
+    { url = "https://files.pythonhosted.org/packages/83/7a/d34f422a021d62420b78f5c538e5b102f62bea616d1d75a13f0a88acb04a/tomli-2.4.1-cp313-cp313-win_arm64.whl", hash = "sha256:4b605484e43cdc43f0954ddae319fb75f04cc10dd80d830540060ee7cd0243cd", size = 95265, upload-time = "2026-03-25T20:21:41.219Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/fb/9a5c8d27dbab540869f7c1f8eb0abb3244189ce780ba9cd73f3770662072/tomli-2.4.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:fd0409a3653af6c147209d267a0e4243f0ae46b011aa978b1080359fddc9b6cf", size = 155726, upload-time = "2026-03-25T20:21:42.23Z" },
+    { url = "https://files.pythonhosted.org/packages/62/05/d2f816630cc771ad836af54f5001f47a6f611d2d39535364f148b6a92d6b/tomli-2.4.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:a120733b01c45e9a0c34aeef92bf0cf1d56cfe81ed9d47d562f9ed591a9828ac", size = 149859, upload-time = "2026-03-25T20:21:43.386Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/48/66341bdb858ad9bd0ceab5a86f90eddab127cf8b046418009f2125630ecb/tomli-2.4.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:559db847dc486944896521f68d8190be1c9e719fced785720d2216fe7022b662", size = 244713, upload-time = "2026-03-25T20:21:44.474Z" },
+    { url = "https://files.pythonhosted.org/packages/df/6d/c5fad00d82b3c7a3ab6189bd4b10e60466f22cfe8a08a9394185c8a8111c/tomli-2.4.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:01f520d4f53ef97964a240a035ec2a869fe1a37dde002b57ebc4417a27ccd853", size = 252084, upload-time = "2026-03-25T20:21:45.62Z" },
+    { url = "https://files.pythonhosted.org/packages/00/71/3a69e86f3eafe8c7a59d008d245888051005bd657760e96d5fbfb0b740c2/tomli-2.4.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7f94b27a62cfad8496c8d2513e1a222dd446f095fca8987fceef261225538a15", size = 247973, upload-time = "2026-03-25T20:21:46.937Z" },
+    { url = "https://files.pythonhosted.org/packages/67/50/361e986652847fec4bd5e4a0208752fbe64689c603c7ae5ea7cb16b1c0ca/tomli-2.4.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:ede3e6487c5ef5d28634ba3f31f989030ad6af71edfb0055cbbd14189ff240ba", size = 256223, upload-time = "2026-03-25T20:21:48.467Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/9a/b4173689a9203472e5467217e0154b00e260621caa227b6fa01feab16998/tomli-2.4.1-cp314-cp314-win32.whl", hash = "sha256:3d48a93ee1c9b79c04bb38772ee1b64dcf18ff43085896ea460ca8dec96f35f6", size = 98973, upload-time = "2026-03-25T20:21:49.526Z" },
+    { url = "https://files.pythonhosted.org/packages/14/58/640ac93bf230cd27d002462c9af0d837779f8773bc03dee06b5835208214/tomli-2.4.1-cp314-cp314-win_amd64.whl", hash = "sha256:88dceee75c2c63af144e456745e10101eb67361050196b0b6af5d717254dddf7", size = 109082, upload-time = "2026-03-25T20:21:50.506Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/2f/702d5e05b227401c1068f0d386d79a589bb12bf64c3d2c72ce0631e3bc49/tomli-2.4.1-cp314-cp314-win_arm64.whl", hash = "sha256:b8c198f8c1805dc42708689ed6864951fd2494f924149d3e4bce7710f8eb5232", size = 96490, upload-time = "2026-03-25T20:21:51.474Z" },
+    { url = "https://files.pythonhosted.org/packages/45/4b/b877b05c8ba62927d9865dd980e34a755de541eb65fffba52b4cc495d4d2/tomli-2.4.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:d4d8fe59808a54658fcc0160ecfb1b30f9089906c50b23bcb4c69eddc19ec2b4", size = 164263, upload-time = "2026-03-25T20:21:52.543Z" },
+    { url = "https://files.pythonhosted.org/packages/24/79/6ab420d37a270b89f7195dec5448f79400d9e9c1826df982f3f8e97b24fd/tomli-2.4.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:7008df2e7655c495dd12d2a4ad038ff878d4ca4b81fccaf82b714e07eae4402c", size = 160736, upload-time = "2026-03-25T20:21:53.674Z" },
+    { url = "https://files.pythonhosted.org/packages/02/e0/3630057d8eb170310785723ed5adcdfb7d50cb7e6455f85ba8a3deed642b/tomli-2.4.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1d8591993e228b0c930c4bb0db464bdad97b3289fb981255d6c9a41aedc84b2d", size = 270717, upload-time = "2026-03-25T20:21:55.129Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/b4/1613716072e544d1a7891f548d8f9ec6ce2faf42ca65acae01d76ea06bb0/tomli-2.4.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:734e20b57ba95624ecf1841e72b53f6e186355e216e5412de414e3c51e5e3c41", size = 278461, upload-time = "2026-03-25T20:21:56.228Z" },
+    { url = "https://files.pythonhosted.org/packages/05/38/30f541baf6a3f6df77b3df16b01ba319221389e2da59427e221ef417ac0c/tomli-2.4.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:8a650c2dbafa08d42e51ba0b62740dae4ecb9338eefa093aa5c78ceb546fcd5c", size = 274855, upload-time = "2026-03-25T20:21:57.653Z" },
+    { url = "https://files.pythonhosted.org/packages/77/a3/ec9dd4fd2c38e98de34223b995a3b34813e6bdadf86c75314c928350ed14/tomli-2.4.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:504aa796fe0569bb43171066009ead363de03675276d2d121ac1a4572397870f", size = 283144, upload-time = "2026-03-25T20:21:59.089Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/be/605a6261cac79fba2ec0c9827e986e00323a1945700969b8ee0b30d85453/tomli-2.4.1-cp314-cp314t-win32.whl", hash = "sha256:b1d22e6e9387bf4739fbe23bfa80e93f6b0373a7f1b96c6227c32bef95a4d7a8", size = 108683, upload-time = "2026-03-25T20:22:00.214Z" },
+    { url = "https://files.pythonhosted.org/packages/12/64/da524626d3b9cc40c168a13da8335fe1c51be12c0a63685cc6db7308daae/tomli-2.4.1-cp314-cp314t-win_amd64.whl", hash = "sha256:2c1c351919aca02858f740c6d33adea0c5deea37f9ecca1cc1ef9e884a619d26", size = 121196, upload-time = "2026-03-25T20:22:01.169Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/cd/e80b62269fc78fc36c9af5a6b89c835baa8af28ff5ad28c7028d60860320/tomli-2.4.1-cp314-cp314t-win_arm64.whl", hash = "sha256:eab21f45c7f66c13f2a9e0e1535309cee140182a9cdae1e041d02e47291e8396", size = 100393, upload-time = "2026-03-25T20:22:02.137Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/61/cceae43728b7de99d9b847560c262873a1f6c98202171fd5ed62640b494b/tomli-2.4.1-py3-none-any.whl", hash = "sha256:0d85819802132122da43cb86656f8d1f8c6587d54ae7dcaf30e90533028b49fe", size = 14583, upload-time = "2026-03-25T20:22:03.012Z" },
+]
+
+[[package]]
+name = "typing-extensions"
+version = "4.15.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/72/94/1a15dd82efb362ac84269196e94cf00f187f7ed21c242792a923cdb1c61f/typing_extensions-4.15.0.tar.gz", hash = "sha256:0cea48d173cc12fa28ecabc3b837ea3cf6f38c6d1136f85cbaaf598984861466", size = 109391, upload-time = "2025-08-25T13:49:26.313Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/18/67/36e9267722cc04a6b9f15c7f3441c2363321a3ea07da7ae0c0707beb2a9c/typing_extensions-4.15.0-py3-none-any.whl", hash = "sha256:f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548", size = 44614, upload-time = "2025-08-25T13:49:24.86Z" },
+]