mainai 0.1.0__tar.gz

mainai-0.1.0/.gitignore

@@ -0,0 +1,10 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+.venv

mainai-0.1.0/.python-version

@@ -0,0 +1 @@
+3.12

mainai-0.1.0/PKG-INFO

@@ -0,0 +1,60 @@
+Metadata-Version: 2.5
+Name: mainai
+Version: 0.1.0
+Summary: Pick the right coding agent to continue a project with, across Claude Code, Codex, and Grok sessions.
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+
+# mainai
+
+A CLI that figures out which coding agent (Claude Code, Codex, Grok, ...)
+last did real work in a project folder, and hands off cleanly to the one you
+pick next.
+
+## The problem
+
+Working the same project folders with several coding agents means that
+coming back months later, it's unclear which agent did the most recent real
+work, and what the other agents did in the meantime.
+
+## What it does
+
+```
+$ mainai .
+Found 6 sessions in ~/Dropbox/inflammatix/projects/endotypes
+  codex   2026-09-25  "fix the endotype clustering..."   <- latest work
+  claude  2026-09-18  "add the GSE cohort loader..."
+  ...
+Continue with: Codex (its edits match the current files)
+Wrote HANDOFF.md (summaries of the 4 Claude sessions)
+Launching: codex "Read HANDOFF.md, then continue where we left off."
+```
+
+1. Reads every agent's stored conversations, keeps the ones for the current
+   folder.
+2. Decides which agent to continue with, based on which session's edits
+   match the files actually on disk (not just the newest timestamp).
+3. Summarizes the relevant parts of the *other* agents' sessions into
+   `HANDOFF.md`.
+4. Starts the chosen agent, pointed at `HANDOFF.md`.
+
+`mainai` with no arguments prints help and does nothing, so a stray bare
+invocation never spends LLM usage. Flags: `--list` (sessions + pick only, no
+LLM, no write), `--agent NAME` (override the pick), `--no-launch` (write
+`HANDOFF.md` but don't start the agent).
+
+See `mainai.md` for the full design notes (reader architecture, per-agent log
+formats, picker logic, summarizer, scope/build order).
+
+## Status
+
+Not yet built. Design only.
+
+## Development
+
+uv-managed project.
+
+```bash
+uv sync
+uv run mainai --list .
+```

mainai-0.1.0/README.md

@@ -0,0 +1,53 @@
+# mainai
+
+A CLI that figures out which coding agent (Claude Code, Codex, Grok, ...)
+last did real work in a project folder, and hands off cleanly to the one you
+pick next.
+
+## The problem
+
+Working the same project folders with several coding agents means that
+coming back months later, it's unclear which agent did the most recent real
+work, and what the other agents did in the meantime.
+
+## What it does
+
+```
+$ mainai .
+Found 6 sessions in ~/Dropbox/inflammatix/projects/endotypes
+  codex   2026-09-25  "fix the endotype clustering..."   <- latest work
+  claude  2026-09-18  "add the GSE cohort loader..."
+  ...
+Continue with: Codex (its edits match the current files)
+Wrote HANDOFF.md (summaries of the 4 Claude sessions)
+Launching: codex "Read HANDOFF.md, then continue where we left off."
+```
+
+1. Reads every agent's stored conversations, keeps the ones for the current
+   folder.
+2. Decides which agent to continue with, based on which session's edits
+   match the files actually on disk (not just the newest timestamp).
+3. Summarizes the relevant parts of the *other* agents' sessions into
+   `HANDOFF.md`.
+4. Starts the chosen agent, pointed at `HANDOFF.md`.
+
+`mainai` with no arguments prints help and does nothing, so a stray bare
+invocation never spends LLM usage. Flags: `--list` (sessions + pick only, no
+LLM, no write), `--agent NAME` (override the pick), `--no-launch` (write
+`HANDOFF.md` but don't start the agent).
+
+See `mainai.md` for the full design notes (reader architecture, per-agent log
+formats, picker logic, summarizer, scope/build order).
+
+## Status
+
+Not yet built. Design only.
+
+## Development
+
+uv-managed project.
+
+```bash
+uv sync
+uv run mainai --list .
+```

mainai-0.1.0/mainai.md

@@ -0,0 +1,156 @@
+# MainAI (mainai) - project brief
+
+Handoff notes from a Claude Code session in ~/Dropbox/ai/ai (2026-10-04/05).
+Nothing has been built yet; this file is the starting point.
+
+## The problem
+
+LB works in the same folders with several coding agents (Claude Code, Codex,
+Grok, maybe Gemini later). Coming back to a project months later, it is
+unclear which agent did the most recent real work, and what the other agents
+did in the meantime.
+
+## What mainai does
+
+One CLI command, run on a project folder:
+
+1. Read every agent's stored conversations, keep the ones for that folder.
+2. Decide which agent to continue with.
+3. Summarize the relevant parts of the *other* agents' sessions into
+   HANDOFF.md.
+4. Start the chosen agent, already pointed at HANDOFF.md.
+
+## User interaction (decided)
+
+A single command. Remembering two commands was called a showstopper.
+
+```
+$ mainai .
+Found 6 sessions in ~/Dropbox/inflammatix/projects/endotypes
+  codex   2026-09-25  "fix the endotype clustering..."   <- latest work
+  claude  2026-09-18  "add the GSE cohort loader..."
+  ...
+Continue with: Codex (its edits match the current files)
+Wrote HANDOFF.md (summaries of the 4 Claude sessions)
+Launching: codex "Read HANDOFF.md, then continue where we left off."
+```
+
+- `mainai` with no arguments prints help and does nothing. The folder
+  argument (`.`) is the "go" signal, so a stray bare `mainai` never spends
+  LLM usage.
+- Optional flags:
+  - `--list`: show sessions and the pick only; no LLM call, writes nothing
+  - `--agent NAME`: override the pick
+  - `--no-launch`: write HANDOFF.md but do not start the agent
+- Launching works because `claude`, `codex` and `grok` all accept a starting
+  prompt on the command line.
+
+## Design
+
+1. **One reader per agent.** Each converts its own log format into a common
+   record: agent, session id, folder (cwd), start/end time, turns (role,
+   text), files touched, commands run. A new agent = one new reader.
+2. **Filter by folder.** Match the session's cwd to the target folder or a
+   subfolder.
+3. **Pick the agent.** Raw "latest message" can mislead (a trivial side
+   question can be the newest message). The stronger signal is file evidence:
+   compare the files each session wrote with what is on disk now. The session
+   whose edits match the current files did the latest real work. Use git
+   history too when the folder is a repo. Print the pick and the reasons.
+4. **Summarize the others.** First extract without an LLM (user prompts, final
+   assistant answers, files changed, decisions, errors), then have an LLM
+   condense that into HANDOFF.md with sections: goal, done, decisions + why,
+   open items, gotchas, key files. Tag each item with agent and date.
+5. **Hand off.** Launch the chosen agent with a prompt to read HANDOFF.md.
+
+## Summarizer: `claude -p` (recommended)
+
+Claude Code's headless mode: give it a prompt, it prints the answer and exits.
+It uses the existing Claude login and plan (no API key, no extra
+dependencies). The planned call (flags exist in Claude Code 2.1.289; verify
+the exact combination when building):
+
+```
+claude -p "<summarize instructions>" --model sonnet --output-format json \
+       --no-session-persistence --tools ""
+```
+
+- `--no-session-persistence` is essential: without it, each summarizing run
+  saves its own transcript into ~/.claude/projects, and mainai would then
+  read and summarize its own runs.
+- `--tools ""` (or a minimal list): the summarizer only needs the text given.
+- Keep the summarizer behind a small interface so the Anthropic API,
+  `codex exec` or `grok -p` can be swapped in with a flag.
+- Privacy: the transcripts (including Codex/Grok ones) go to Anthropic.
+
+The API alternative needs a key, bills per token separately and adds a
+dependency, but gives full control (caching, batching). Not worth it for a
+personal tool.
+
+## Where each agent stores sessions (verified on disk)
+
+Locations differ per machine. Two machines so far:
+
+| Agent | beograd (laptop) | ljubljana |
+|---|---|---|
+| Claude Code | ~/.claude/projects/<path-slug>/<session>.jsonl | same |
+| Codex | ~/snap/codex/<rev>/sessions/YYYY/MM/DD/rollout-*.jsonl (snap; check data survives snap refreshes) | ~/.codex/sessions/YYYY/MM/DD/rollout-*.jsonl (48 files, 2025-09 to 2026-09) |
+| Grok | not installed | ~/.grok/sessions/<url-encoded cwd>/<session-id>/ (grok 1.0.44) |
+| Gemini | not installed | not installed |
+
+Format notes:
+
+- **Claude Code**: JSONL, one event per line. `cwd`, `timestamp`,
+  `sessionId`, `gitBranch` on each user/assistant line. Path slug = cwd with
+  `/` replaced by `-`. Also a `sessions-index.json` per project dir.
+- **Codex**: JSONL. First line `type: session_meta` with `payload.cwd`,
+  `payload.id`, `payload.timestamp`. Then `response_item` (message,
+  function_call, function_call_output, reasoning), `event_msg` (user_message,
+  agent_message, token_count), `turn_context`. Also ~/.codex/history.jsonl
+  and ~/.codex/session_index.jsonl on ljubljana.
+- **Grok**: the folder name is the URL-encoded cwd (e.g.
+  `%2Fhome%2Fljubomir%2FDropbox%2Fai%2Fcvic`), which makes folder filtering
+  easy. Per session: `chat_history.jsonl` (messages; first line is the system
+  prompt), `events.jsonl` (ts, type, session_id, model_id), `summary.json`,
+  `rewind_points.jsonl`, `updates.jsonl`. Per folder: `prompt_history.jsonl`.
+  Also ~/.grok/sessions/session_search.sqlite. Not parsed in detail yet.
+
+All formats are undocumented and change between versions; readers must be
+tolerant (skip unknown line types, never crash on one bad line).
+
+## Retention: Claude Code deletes old transcripts
+
+Claude Code deletes transcripts after 30 days by default
+(`cleanupPeriodDays`). On beograd only 5 transcripts were left (oldest
+2026-09-15). So for 6-month-old work, Claude's side may simply be gone.
+
+- beograd: `"cleanupPeriodDays": 36500` set in ~/.claude/settings.json on
+  2026-10-04.
+- ljubljana: set on 2026-10-05 (9 transcripts left, oldest 2026-09-04).
+
+mainai should warn when a folder has no or few Claude sessions and the
+setting is at its default.
+
+## Scope
+
+- v1: Claude Code + Codex readers. Grok reader next (its data is on
+  ljubljana). Gemini when installed.
+- Build order: readers + session listing (`mainai . --list`) first, no LLM,
+  to check it finds the right sessions; then the picker; then the summarizer
+  and launch.
+
+## GitHub release (discussed, not decided)
+
+Plausibly worth releasing: multi-agent users are a growing group, and
+cross-agent handoff is the distinguishing feature; per-agent readers invite
+contributions. The cost is maintenance: undocumented log formats break
+readers on agent upgrades. Plan: use it personally for a few weeks first,
+search GitHub for prior art, then decide (or publish "as-is").
+
+## Conventions
+
+- Python, uv-managed venv (no system pip installs). Executable entry point
+  with a shebang and argparse help that shows option defaults.
+- Never write `__pycache__` (check the global CLAUDE.md on the machine in
+  use; the shebang convention differs between beograd and ljubljana).
+- Markdown/text files plain ASCII (LB edits in Emacs).

mainai-0.1.0/pyproject.toml

@@ -0,0 +1,22 @@
+[project]
+name = "mainai"
+version = "0.1.0"
+description = "Pick the right coding agent to continue a project with, across Claude Code, Codex, and Grok sessions."
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = []
+
+[project.scripts]
+mainai = "mainai.cli:main"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/mainai"]
+
+[dependency-groups]
+dev = [
+    "pytest>=9.1.1",
+]

mainai-0.1.0/src/mainai/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

mainai-0.1.0/src/mainai/cli.py

@@ -0,0 +1,148 @@
+"""mainai -- pick which coding agent to continue a project with."""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+
+from mainai import __version__, llm
+from mainai.llm_picker import llm_pick
+from mainai.picker import Pick, heuristic_pick
+from mainai.readers import all_sessions_for
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="mainai",
+        description=(
+            "Find which coding agent (Claude Code, Codex, ...) last did real "
+            "work in a project folder, and show which one to continue with. "
+            "Run with no arguments to process the current directory."
+        ),
+    )
+    parser.add_argument(
+        "folder",
+        nargs="?",
+        default=".",
+        help="project folder to inspect (default: current directory)",
+    )
+    parser.add_argument(
+        "--list",
+        action="store_true",
+        help=(
+            "show the sessions found and a quick file-evidence guess, nothing "
+            "else (no file written, no LLM call)"
+        ),
+    )
+    parser.add_argument(
+        "--agent",
+        metavar="NAME",
+        help="override the pick, e.g. --agent codex (no LLM call)",
+    )
+    parser.add_argument(
+        "--handoff",
+        action="store_true",
+        help="also summarize the other agents' sessions into HANDOFF.md (uses an LLM)",
+    )
+    parser.add_argument(
+        "-y",
+        "--yes",
+        action="store_true",
+        help=(
+            "don't ask for confirmation before an LLM call that would bill "
+            "ANTHROPIC_API_KEY directly (no claude.ai subscription login found)"
+        ),
+    )
+    parser.add_argument(
+        "--version",
+        action="version",
+        version=f"%(prog)s {__version__}",
+    )
+    return parser
+
+
+def _confirm_api_key_billing(yes: bool) -> bool:
+    print(
+        "mainai: no claude.ai subscription login found; the LLM pick would bill "
+        "ANTHROPIC_API_KEY directly (pay-per-token), not a subscription.",
+        file=sys.stderr,
+    )
+    if yes:
+        return True
+    if not sys.stdin.isatty():
+        print(
+            "mainai: not an interactive terminal; re-run with --yes to proceed anyway, "
+            "or use --list / --agent to avoid the LLM call.",
+            file=sys.stderr,
+        )
+        return False
+    reply = input("Proceed and bill ANTHROPIC_API_KEY for this call? [y/N] ").strip().lower()
+    return reply in ("y", "yes")
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+
+    folder = Path(args.folder).expanduser()
+    if not folder.is_dir():
+        print(f"mainai: {folder} is not a directory", file=sys.stderr)
+        return 1
+
+    sessions = all_sessions_for(folder)
+
+    if not sessions:
+        print(f"No sessions found for {folder.resolve()}")
+        return 0
+
+    if args.agent:
+        chosen = next((s for s in sessions if s.agent == args.agent), None)
+        if chosen is None:
+            print(f"mainai: no session found for agent '{args.agent}'", file=sys.stderr)
+            return 1
+        result = Pick(session=chosen, reasons=[f"overridden with --agent {args.agent}"])
+    elif args.list:
+        result = heuristic_pick(sessions, folder)
+    else:
+        auth_mode = llm.determine_auth_mode()
+        if auth_mode == llm.AuthMode.UNAVAILABLE:
+            print(
+                "mainai: no usable `claude` auth found (no claude.ai login, no "
+                "ANTHROPIC_API_KEY). Run `claude login`, or use --list / --agent "
+                "to avoid the LLM call.",
+                file=sys.stderr,
+            )
+            return 1
+        if auth_mode == llm.AuthMode.API_KEY and not _confirm_api_key_billing(args.yes):
+            print("mainai: aborted.", file=sys.stderr)
+            return 1
+        result = llm_pick(sessions, folder)
+
+    chosen = result.session
+
+    print(f"Found {len(sessions)} session(s) in {folder.resolve()}")
+    for session in sessions:
+        marker = "  <- latest work" if session is chosen else ""
+        print(f'  {session.agent:<8} {session.end.date()}  "{session.summary}"{marker}')
+
+    if args.list:
+        return 0
+
+    if chosen is None:
+        return 0
+
+    print()
+    print(f"Continue with: {chosen.agent} ({'; '.join(result.reasons)})")
+    print(f"  Advice: cd {chosen.cwd} && {chosen.agent}")
+
+    if args.handoff:
+        print()
+        print("mainai: --handoff (LLM summarizer) is not implemented yet.", file=sys.stderr)
+        return 1
+
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

mainai-0.1.0/src/mainai/llm.py

@@ -0,0 +1,112 @@
+"""Thin wrapper around calling an LLM in headless/non-interactive mode.
+
+Default backend is `claude -p` (Claude Code headless mode): no separate API
+key needed when the user has a claude.ai login, since it draws on that
+login's included usage. Kept behind this small interface so `codex exec` or
+`grok -p` can be swapped in later (see mainai.md).
+
+Many developers keep ANTHROPIC_API_KEY set for their own API projects, and
+`claude -p` prefers that key over a claude.ai login when both are present.
+mainai must not silently bill someone's personal API key for a background
+utility call, so every call here strips ANTHROPIC_API_KEY from the
+subprocess environment whenever a claude.ai login is available
+(`determine_auth_mode` -> AuthMode.SUBSCRIPTION). When no claude.ai login
+exists, the caller (mainai.cli) must get explicit confirmation before a call
+that will bill the API key.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import shutil
+import subprocess
+from enum import Enum
+
+
+class LLMError(RuntimeError):
+    pass
+
+
+class AuthMode(Enum):
+    SUBSCRIPTION = "subscription"  # claude.ai login available; API key (if any) is stripped
+    API_KEY = "api_key"  # no claude.ai login; a call would bill ANTHROPIC_API_KEY
+    UNAVAILABLE = "unavailable"  # claude CLI missing, or no usable auth at all
+
+
+def determine_auth_mode() -> AuthMode:
+    if shutil.which("claude") is None:
+        return AuthMode.UNAVAILABLE
+
+    env = dict(os.environ)
+    env.pop("ANTHROPIC_API_KEY", None)
+    status: dict = {}
+    try:
+        result = subprocess.run(
+            ["claude", "auth", "status"],
+            capture_output=True,
+            text=True,
+            timeout=15,
+            env=env,
+        )
+        status = json.loads(result.stdout)
+    except (subprocess.SubprocessError, OSError, json.JSONDecodeError):
+        status = {}
+
+    if status.get("loggedIn") and status.get("authMethod") == "claude.ai":
+        return AuthMode.SUBSCRIPTION
+    if os.environ.get("ANTHROPIC_API_KEY"):
+        return AuthMode.API_KEY
+    return AuthMode.UNAVAILABLE
+
+
+def call(prompt: str, *, model: str = "sonnet", timeout: int = 180) -> str:
+    """Run `prompt` through `claude -p` and return the text result.
+
+    Raises LLMError on anything that keeps the caller from getting a usable
+    answer: missing CLI, process failure, timeout, or unparseable output.
+    """
+    if shutil.which("claude") is None:
+        raise LLMError("the `claude` CLI is not on PATH")
+
+    env = dict(os.environ)
+    if determine_auth_mode() == AuthMode.SUBSCRIPTION:
+        env.pop("ANTHROPIC_API_KEY", None)
+
+    try:
+        result = subprocess.run(
+            [
+                "claude",
+                "-p",
+                prompt,
+                "--model",
+                model,
+                "--output-format",
+                "json",
+                "--no-session-persistence",
+                "--tools",
+                "",
+            ],
+            capture_output=True,
+            text=True,
+            timeout=timeout,
+            env=env,
+        )
+    except subprocess.SubprocessError as exc:
+        raise LLMError(f"failed to run claude -p: {exc}") from exc
+
+    if result.returncode != 0:
+        raise LLMError(f"claude -p exited {result.returncode}: {result.stderr.strip()}")
+
+    try:
+        payload = json.loads(result.stdout)
+    except json.JSONDecodeError as exc:
+        raise LLMError(f"could not parse claude -p output as JSON: {exc}") from exc
+
+    if payload.get("is_error"):
+        raise LLMError(f"claude -p reported an error: {payload.get('result')}")
+
+    text = payload.get("result")
+    if not text:
+        raise LLMError("claude -p returned no text result")
+    return text

mainai-0.1.0/src/mainai/llm_picker.py

@@ -0,0 +1,92 @@
+"""LLM-based picker: this is mainai's default decision maker.
+
+Instead of only the file-evidence heuristic in `picker.py`, this asks an LLM
+to actually read each session's content -- the summary/title, a capped
+excerpt of turns, the files it touched that still exist on disk, and the
+commands it ran -- and recommend which agent to continue with, in its own
+words. Falls back to `picker.heuristic_pick` when the LLM call fails (CLI
+missing, timeout, bad output) or there's only one session to begin with.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from mainai import llm
+from mainai.models import Session
+from mainai.picker import Pick, heuristic_pick
+
+MAX_TURN_CHARS = 400
+MAX_TURNS_PER_SESSION = 6
+
+
+def llm_pick(sessions: list[Session], folder: Path) -> Pick:
+    if not sessions:
+        return Pick(session=None, reasons=["no sessions found for this folder"])
+    if len(sessions) == 1:
+        return Pick(session=sessions[0], reasons=["only one session found"])
+
+    try:
+        raw = llm.call(_build_prompt(sessions, folder))
+        data = json.loads(raw)
+        agent = data["agent"]
+        reason = str(data.get("reason", "")).strip()
+    except (llm.LLMError, json.JSONDecodeError, KeyError, TypeError) as exc:
+        fallback = heuristic_pick(sessions, folder)
+        fallback.reasons.insert(
+            0, f"LLM pick unavailable ({exc}); used file-evidence heuristic instead"
+        )
+        return fallback
+
+    matches = [s for s in sessions if s.agent == agent]
+    if not matches:
+        fallback = heuristic_pick(sessions, folder)
+        fallback.reasons.insert(
+            0,
+            f"LLM named unrecognized agent '{agent}'; used file-evidence heuristic instead",
+        )
+        return fallback
+
+    chosen = max(matches, key=lambda s: s.end)
+    return Pick(session=chosen, reasons=[reason] if reason else ["LLM pick"])
+
+
+def _session_excerpt(session: Session) -> dict:
+    existing_files = sorted(f for f in session.files_touched if Path(f).exists())
+    turns = [
+        f"{turn.role}: {turn.text[:MAX_TURN_CHARS]}"
+        for turn in session.turns[:MAX_TURNS_PER_SESSION]
+        if turn.text.strip()
+    ]
+    return {
+        "agent": session.agent,
+        "start": session.start.isoformat(),
+        "end": session.end.isoformat(),
+        "title": session.title,
+        "files_touched_still_on_disk": existing_files,
+        "commands_run": session.commands_run[:10],
+        "turns_excerpt": turns,
+    }
+
+
+def _build_prompt(sessions: list[Session], folder: Path) -> str:
+    data = [_session_excerpt(s) for s in sessions]
+    agents = sorted({s.agent for s in sessions})
+    return (
+        "A developer worked on the same project folder using several different "
+        "coding agents (Claude Code, Codex, Grok, ...), at different times. Below "
+        "are summaries of each agent's most recent session in this folder. Decide "
+        "which session represents the most recent REAL work worth continuing from. "
+        "A session's newest message timestamp alone can be misleading -- e.g. a "
+        "trivial side question can be the newest message in an otherwise stale "
+        "session. Weigh the actual conversation content, the files it touched that "
+        "still exist on disk, and the commands it ran.\n\n"
+        f"Project folder: {folder}\n"
+        f"Candidate agents: {', '.join(agents)}\n\n"
+        "Sessions (JSON):\n"
+        f"{json.dumps(data, indent=2)}\n\n"
+        "Reply with ONLY a JSON object and nothing else, in this exact shape:\n"
+        '{"agent": "<one of the candidate agents above>", '
+        '"reason": "<one or two sentence explanation a developer would find useful>"}'
+    )

mainai-0.1.0/src/mainai/models.py

@@ -0,0 +1,35 @@
+"""Common record types every per-agent reader converts its log format into."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import datetime
+
+
+@dataclass
+class Turn:
+    role: str  # "user" | "assistant"
+    text: str
+    timestamp: datetime | None = None
+
+
+@dataclass
+class Session:
+    agent: str  # "claude", "codex", "grok", ...
+    session_id: str
+    cwd: str
+    start: datetime
+    end: datetime
+    title: str | None = None
+    turns: list[Turn] = field(default_factory=list)
+    files_touched: set[str] = field(default_factory=set)
+    commands_run: list[str] = field(default_factory=list)
+
+    @property
+    def summary(self) -> str:
+        if self.title:
+            return self.title
+        for turn in self.turns:
+            if turn.role == "user" and turn.text.strip():
+                return turn.text.strip().splitlines()[0][:80]
+        return "(no prompt text found)"

mainai-0.1.0/src/mainai/picker.py

@@ -0,0 +1,80 @@
+"""Heuristic, LLM-free picker: file evidence + git history only.
+
+This is no longer mainai's default decision maker -- see `llm_picker` for
+that, which asks an LLM to read the actual session content. This module is
+kept as the free, instant path for `--list`, and as the fallback when the
+LLM call fails or isn't available.
+
+Raw "latest message" can mislead -- a trivial side question can be the
+newest turn. The stronger signal is file evidence: does a file the session
+touched still exist on disk, matching what the session wrote. Git history is
+used as a secondary cross-check when the folder is a repo.
+"""
+
+from __future__ import annotations
+
+import subprocess
+from dataclasses import dataclass
+from datetime import datetime
+from pathlib import Path
+
+from mainai.models import Session
+
+
+@dataclass
+class Pick:
+    session: Session | None
+    reasons: list[str]
+
+
+def heuristic_pick(sessions: list[Session], folder: Path) -> Pick:
+    if not sessions:
+        return Pick(session=None, reasons=["no sessions found for this folder"])
+
+    folder = folder.resolve()
+    latest_commit_ts = _latest_git_commit_timestamp(folder)
+
+    scored = []
+    for session in sessions:
+        existing = {f for f in session.files_touched if Path(f).exists()}
+        scored.append((session, bool(existing), len(existing)))
+
+    scored.sort(key=lambda item: (item[1], item[2], item[0].end), reverse=True)
+    best_session, has_evidence, existing_count = scored[0]
+
+    reasons = []
+    if has_evidence:
+        reasons.append(f"{existing_count} file(s) it touched still exist on disk")
+    else:
+        reasons.append("no session has file evidence on disk; picked by latest activity")
+    reasons.append(f"most recent turn {best_session.end.isoformat()}")
+
+    if latest_commit_ts is not None:
+        if best_session.start <= latest_commit_ts <= best_session.end:
+            reasons.append("its time range contains the latest git commit")
+        else:
+            reasons.append(f"latest git commit was at {latest_commit_ts.isoformat()}")
+
+    return Pick(session=best_session, reasons=reasons)
+
+
+def _latest_git_commit_timestamp(folder: Path) -> datetime | None:
+    if not (folder / ".git").exists():
+        return None
+    try:
+        result = subprocess.run(
+            ["git", "-C", str(folder), "log", "-1", "--format=%cI"],
+            capture_output=True,
+            text=True,
+            timeout=5,
+            check=True,
+        )
+    except (subprocess.SubprocessError, OSError):
+        return None
+    value = result.stdout.strip()
+    if not value:
+        return None
+    try:
+        return datetime.fromisoformat(value)
+    except ValueError:
+        return None

mainai-0.1.0/src/mainai/readers/__init__.py

@@ -0,0 +1,25 @@
+"""One reader per coding agent. Each exposes `sessions_for(folder)` and returns
+a list of `mainai.models.Session`, filtered to sessions whose cwd is the given
+folder or a subfolder of it. Readers must never crash on a malformed or
+unrecognized log line -- skip it and move on.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from mainai.models import Session
+from mainai.readers import claude_code, codex
+
+READERS = {
+    "claude": claude_code.sessions_for,
+    "codex": codex.sessions_for,
+}
+
+
+def all_sessions_for(folder: Path) -> list[Session]:
+    sessions: list[Session] = []
+    for reader in READERS.values():
+        sessions.extend(reader(folder))
+    sessions.sort(key=lambda s: s.end, reverse=True)
+    return sessions

mainai-0.1.0/src/mainai/readers/claude_code.py

@@ -0,0 +1,141 @@
+"""Reader for Claude Code's own transcripts.
+
+Format: JSONL under ~/.claude/projects/<cwd-slug>/<session-id>.jsonl, one
+event per line. `cwd`, `timestamp`, `sessionId` appear on most event types.
+The format is undocumented and has grown new event types across versions
+(mode, permission-mode, file-history-snapshot, attachment, ai-title, ...);
+this reader only looks at the few types it understands and skips the rest.
+"""
+
+from __future__ import annotations
+
+import json
+from datetime import datetime
+from pathlib import Path
+
+from mainai.models import Session, Turn
+
+PROJECTS_DIR = Path.home() / ".claude" / "projects"
+
+EDIT_TOOLS = {"Edit", "Write", "NotebookEdit", "MultiEdit"}
+
+
+def sessions_for(folder: Path) -> list[Session]:
+    folder = folder.resolve()
+    if not PROJECTS_DIR.is_dir():
+        return []
+
+    sessions = []
+    for project_dir in PROJECTS_DIR.iterdir():
+        if not project_dir.is_dir():
+            continue
+        for jsonl_path in project_dir.glob("*.jsonl"):
+            session = _read_session(jsonl_path, folder)
+            if session is not None:
+                sessions.append(session)
+    return sessions
+
+
+def _read_session(path: Path, folder: Path) -> Session | None:
+    session_id = path.stem
+    cwd: str | None = None
+    title: str | None = None
+    start: datetime | None = None
+    end: datetime | None = None
+    turns: list[Turn] = []
+    files_touched: set[str] = set()
+    commands_run: list[str] = []
+
+    try:
+        lines = path.read_text(encoding="utf-8", errors="replace").splitlines()
+    except OSError:
+        return None
+
+    for line in lines:
+        line = line.strip()
+        if not line:
+            continue
+        try:
+            event = json.loads(line)
+        except json.JSONDecodeError:
+            continue
+        if not isinstance(event, dict):
+            continue
+
+        event_cwd = event.get("cwd")
+        if event_cwd:
+            cwd = event_cwd
+
+        ts = _parse_timestamp(event.get("timestamp"))
+        if ts is not None:
+            if start is None or ts < start:
+                start = ts
+            if end is None or ts > end:
+                end = ts
+
+        event_type = event.get("type")
+
+        if event_type == "ai-title":
+            title = event.get("aiTitle") or title
+            continue
+
+        if event_type not in ("user", "assistant"):
+            continue
+
+        message = event.get("message")
+        if not isinstance(message, dict):
+            continue
+        role = message.get("role", event_type)
+        content = message.get("content")
+
+        if isinstance(content, str):
+            if not event.get("isMeta") and content.strip():
+                turns.append(Turn(role=role, text=content, timestamp=ts))
+        elif isinstance(content, list):
+            for block in content:
+                if not isinstance(block, dict):
+                    continue
+                block_type = block.get("type")
+                if block_type == "text" and not event.get("isMeta"):
+                    text = block.get("text", "")
+                    if text.strip():
+                        turns.append(Turn(role=role, text=text, timestamp=ts))
+                elif block_type == "tool_use":
+                    name = block.get("name")
+                    tool_input = block.get("input") or {}
+                    if name in EDIT_TOOLS:
+                        file_path = tool_input.get("file_path")
+                        if file_path:
+                            files_touched.add(file_path)
+                    elif name == "Bash":
+                        command = tool_input.get("command")
+                        if command:
+                            commands_run.append(command)
+
+    if cwd is None or start is None or end is None:
+        return None
+
+    cwd_path = Path(cwd).resolve()
+    if cwd_path != folder and folder not in cwd_path.parents:
+        return None
+
+    return Session(
+        agent="claude",
+        session_id=session_id,
+        cwd=cwd,
+        start=start,
+        end=end,
+        title=title,
+        turns=turns,
+        files_touched=files_touched,
+        commands_run=commands_run,
+    )
+
+
+def _parse_timestamp(value: object) -> datetime | None:
+    if not isinstance(value, str) or not value:
+        return None
+    try:
+        return datetime.fromisoformat(value.replace("Z", "+00:00"))
+    except ValueError:
+        return None

mainai-0.1.0/src/mainai/readers/codex.py

@@ -0,0 +1,144 @@
+"""Reader for Codex CLI session logs.
+
+Format: JSONL under ~/.codex/sessions/YYYY/MM/DD/rollout-*.jsonl (or, when
+Codex is installed via snap, ~/snap/codex/<rev>/sessions/YYYY/MM/DD/). First
+line is `type: session_meta` with `payload.cwd`, `payload.id`,
+`payload.timestamp`. Then `response_item` (message, function_call,
+function_call_output, reasoning), `event_msg`, `turn_context`. Undocumented
+and version-dependent; unrecognized line types and payload shapes are
+skipped.
+
+Codex has no dedicated "edit file" tool call in the sessions seen so far --
+file edits happen via shell commands run through `exec_command` -- so
+`files_touched` is left empty here; only `commands_run` is populated.
+"""
+
+from __future__ import annotations
+
+import json
+from datetime import datetime
+from pathlib import Path
+
+from mainai.models import Session, Turn
+
+
+def _session_bases() -> list[Path]:
+    bases = [Path.home() / ".codex" / "sessions"]
+    snap_root = Path.home() / "snap" / "codex"
+    if snap_root.is_dir():
+        for rev_dir in snap_root.iterdir():
+            candidate = rev_dir / "sessions"
+            if candidate.is_dir():
+                bases.append(candidate)
+    return bases
+
+
+def sessions_for(folder: Path) -> list[Session]:
+    folder = folder.resolve()
+    sessions = []
+    for base in _session_bases():
+        if not base.is_dir():
+            continue
+        for jsonl_path in base.glob("*/*/*/rollout-*.jsonl"):
+            session = _read_session(jsonl_path, folder)
+            if session is not None:
+                sessions.append(session)
+    return sessions
+
+
+def _read_session(path: Path, folder: Path) -> Session | None:
+    session_id: str | None = None
+    cwd: str | None = None
+    start: datetime | None = None
+    end: datetime | None = None
+    turns: list[Turn] = []
+    commands_run: list[str] = []
+
+    try:
+        lines = path.read_text(encoding="utf-8", errors="replace").splitlines()
+    except OSError:
+        return None
+
+    for line in lines:
+        line = line.strip()
+        if not line:
+            continue
+        try:
+            event = json.loads(line)
+        except json.JSONDecodeError:
+            continue
+        if not isinstance(event, dict):
+            continue
+
+        ts = _parse_timestamp(event.get("timestamp"))
+        if ts is not None:
+            if start is None or ts < start:
+                start = ts
+            if end is None or ts > end:
+                end = ts
+
+        event_type = event.get("type")
+        payload = event.get("payload")
+        if not isinstance(payload, dict):
+            continue
+
+        if event_type == "session_meta":
+            session_id = payload.get("id") or payload.get("session_id") or session_id
+            cwd = payload.get("cwd") or cwd
+            continue
+
+        if event_type != "response_item":
+            continue
+
+        item_type = payload.get("type")
+
+        if item_type == "message":
+            role = payload.get("role")
+            if role not in ("user", "assistant"):
+                continue
+            content = payload.get("content")
+            if not isinstance(content, list):
+                continue
+            text = "".join(
+                block.get("text", "")
+                for block in content
+                if isinstance(block, dict)
+                and block.get("type") in ("input_text", "output_text", "text")
+            ).strip()
+            if not text or text.startswith("<environment_context>"):
+                continue
+            turns.append(Turn(role=role, text=text, timestamp=ts))
+        elif item_type == "function_call" and payload.get("name") == "exec_command":
+            try:
+                arguments = json.loads(payload.get("arguments") or "{}")
+            except json.JSONDecodeError:
+                arguments = {}
+            command = arguments.get("cmd")
+            if command:
+                commands_run.append(command)
+
+    if session_id is None or cwd is None or start is None or end is None:
+        return None
+
+    cwd_path = Path(cwd).resolve()
+    if cwd_path != folder and folder not in cwd_path.parents:
+        return None
+
+    return Session(
+        agent="codex",
+        session_id=session_id,
+        cwd=cwd,
+        start=start,
+        end=end,
+        turns=turns,
+        commands_run=commands_run,
+    )
+
+
+def _parse_timestamp(value: object) -> datetime | None:
+    if not isinstance(value, str) or not value:
+        return None
+    try:
+        return datetime.fromisoformat(value.replace("Z", "+00:00"))
+    except ValueError:
+        return None

mainai-0.1.0/tests/test_claude_code_reader.py

@@ -0,0 +1,108 @@
+import json
+from pathlib import Path
+
+from mainai.readers import claude_code
+
+
+def _write_jsonl(path: Path, events: list[dict]) -> None:
+    path.write_text("\n".join(json.dumps(e) for e in events), encoding="utf-8")
+
+
+def test_reads_session_matching_folder(tmp_path, monkeypatch):
+    project_dir = tmp_path / "projects" / "-home-user-proj"
+    project_dir.mkdir(parents=True)
+    target = tmp_path / "home" / "user" / "proj"
+    target.mkdir(parents=True)
+
+    events = [
+        {
+            "type": "user",
+            "message": {"role": "user", "content": "fix the bug"},
+            "timestamp": "2026-01-01T00:00:00Z",
+            "cwd": str(target),
+        },
+        {
+            "type": "assistant",
+            "message": {
+                "role": "assistant",
+                "content": [
+                    {"type": "text", "text": "done"},
+                    {
+                        "type": "tool_use",
+                        "name": "Edit",
+                        "input": {"file_path": str(target / "a.py")},
+                    },
+                ],
+            },
+            "timestamp": "2026-01-01T00:05:00Z",
+            "cwd": str(target),
+        },
+        {"type": "ai-title", "aiTitle": "Fix the bug"},
+    ]
+    _write_jsonl(project_dir / "session1.jsonl", events)
+
+    monkeypatch.setattr(claude_code, "PROJECTS_DIR", tmp_path / "projects")
+
+    sessions = claude_code.sessions_for(target)
+
+    assert len(sessions) == 1
+    session = sessions[0]
+    assert session.agent == "claude"
+    assert session.title == "Fix the bug"
+    assert str(target / "a.py") in session.files_touched
+    assert any(t.text == "fix the bug" for t in session.turns)
+
+
+def test_skips_malformed_lines_without_crashing(tmp_path, monkeypatch):
+    project_dir = tmp_path / "projects" / "-home-user-proj"
+    project_dir.mkdir(parents=True)
+    target = tmp_path / "home" / "user" / "proj"
+    target.mkdir(parents=True)
+
+    path = project_dir / "session2.jsonl"
+    path.write_text(
+        "not json at all\n"
+        + json.dumps({"type": "unknown-future-type", "stuff": 1})
+        + "\n"
+        + json.dumps(
+            {
+                "type": "user",
+                "message": {"role": "user", "content": "hello"},
+                "timestamp": "2026-01-01T00:00:00Z",
+                "cwd": str(target),
+            }
+        ),
+        encoding="utf-8",
+    )
+
+    monkeypatch.setattr(claude_code, "PROJECTS_DIR", tmp_path / "projects")
+
+    sessions = claude_code.sessions_for(target)
+
+    assert len(sessions) == 1
+    assert sessions[0].turns[0].text == "hello"
+
+
+def test_excludes_sessions_outside_folder(tmp_path, monkeypatch):
+    project_dir = tmp_path / "projects" / "-other"
+    project_dir.mkdir(parents=True)
+    other = tmp_path / "other"
+    other.mkdir()
+    target = tmp_path / "home" / "user" / "proj"
+    target.mkdir(parents=True)
+
+    _write_jsonl(
+        project_dir / "session3.jsonl",
+        [
+            {
+                "type": "user",
+                "message": {"role": "user", "content": "unrelated"},
+                "timestamp": "2026-01-01T00:00:00Z",
+                "cwd": str(other),
+            }
+        ],
+    )
+
+    monkeypatch.setattr(claude_code, "PROJECTS_DIR", tmp_path / "projects")
+
+    assert claude_code.sessions_for(target) == []

mainai-0.1.0/tests/test_llm_picker.py

@@ -0,0 +1,66 @@
+from datetime import datetime, timezone
+from pathlib import Path
+
+import pytest
+
+from mainai import llm, llm_picker
+from mainai.models import Session
+
+
+def _session(agent: str, end_hour: int) -> Session:
+    return Session(
+        agent=agent,
+        session_id=f"{agent}-1",
+        cwd="/tmp/proj",
+        start=datetime(2026, 1, 1, 0, tzinfo=timezone.utc),
+        end=datetime(2026, 1, 1, end_hour, tzinfo=timezone.utc),
+        title=f"{agent} session",
+        turns=[],
+    )
+
+
+def test_single_session_skips_llm(monkeypatch):
+    def fail(*a, **k):
+        raise AssertionError("llm.call should not be invoked for a single session")
+
+    monkeypatch.setattr(llm, "call", fail)
+    sessions = [_session("claude", 1)]
+    result = llm_picker.llm_pick(sessions, Path("/tmp/proj"))
+    assert result.session is sessions[0]
+
+
+def test_falls_back_to_heuristic_on_llm_error(monkeypatch):
+    def raise_error(*a, **k):
+        raise llm.LLMError("claude not found")
+
+    monkeypatch.setattr(llm, "call", raise_error)
+    sessions = [_session("claude", 1), _session("codex", 2)]
+    result = llm_picker.llm_pick(sessions, Path("/tmp/proj"))
+    assert result.session is not None
+    assert "LLM pick unavailable" in result.reasons[0]
+
+
+def test_falls_back_on_unparseable_response(monkeypatch):
+    monkeypatch.setattr(llm, "call", lambda *a, **k: "not json")
+    sessions = [_session("claude", 1), _session("codex", 2)]
+    result = llm_picker.llm_pick(sessions, Path("/tmp/proj"))
+    assert result.session is not None
+    assert "LLM pick unavailable" in result.reasons[0]
+
+
+def test_uses_llm_choice(monkeypatch):
+    monkeypatch.setattr(
+        llm, "call", lambda *a, **k: '{"agent": "codex", "reason": "it did the real work"}'
+    )
+    sessions = [_session("claude", 1), _session("codex", 2)]
+    result = llm_picker.llm_pick(sessions, Path("/tmp/proj"))
+    assert result.session.agent == "codex"
+    assert result.reasons == ["it did the real work"]
+
+
+def test_falls_back_on_unrecognized_agent(monkeypatch):
+    monkeypatch.setattr(llm, "call", lambda *a, **k: '{"agent": "grok", "reason": "x"}')
+    sessions = [_session("claude", 1), _session("codex", 2)]
+    result = llm_picker.llm_pick(sessions, Path("/tmp/proj"))
+    assert result.session is not None
+    assert "unrecognized agent" in result.reasons[0]

mainai-0.1.0/uv.lock

@@ -0,0 +1,79 @@
+version = 1
+revision = 3
+requires-python = ">=3.12"
+
+[[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 = "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 = "mainai"
+version = "0.1.0"
+source = { editable = "." }
+
+[package.dev-dependencies]
+dev = [
+    { name = "pytest" },
+]
+
+[package.metadata]
+
+[package.metadata.requires-dev]
+dev = [{ name = "pytest", specifier = ">=9.1.1" }]
+
+[[package]]
+name = "packaging"
+version = "26.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/7d/fa/3944b40b07da9ce895c0e6303a5ab7d53da063554f534556b134a54d6093/packaging-26.3.tar.gz", hash = "sha256:94edc256424af38762eb31306eed28beb9f0efc50a8837492c9d6fd6004aed79", size = 313412, upload-time = "2026-08-04T18:15:28.737Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/63/34/ba1c580383c9eada3711951fef0795c80b829a078d72188184bcab9dd527/packaging-26.3-py3-none-any.whl", hash = "sha256:d7193f7c8e4e93f444fde0262bf90af30e16fa0ad0ad44cb553c87339b23cd1c", size = 129956, upload-time = "2026-08-04T18:15:27.159Z" },
+]
+
+[[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.21.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/49/2e/ced460408999b33da6b31b0021b0f37d329e202d4169aeb164493778f25b/pygments-2.21.0.tar.gz", hash = "sha256:610ca751c9bc2492b38eb9a38a7fbc93edbbb2d7182edaf34e66ae493dee5c8c", size = 5005329, upload-time = "2026-08-17T08:02:48.824Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/71/46/17f022dd3e953bf20a04a028a21ec746d942f8d2af30fa0f124fa0e6a684/pygments-2.21.0-py3-none-any.whl", hash = "sha256:2363c69b61c4a97c838da3b130dcd6468f4848992b21a82f2a63ec34377137d9", size = 1250147, upload-time = "2026-08-17T08:02:44.912Z" },
+]
+
+[[package]]
+name = "pytest"
+version = "9.1.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+    { name = "iniconfig" },
+    { name = "packaging" },
+    { name = "pluggy" },
+    { name = "pygments" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/e4/47/b9efed96c114afcfa3c9d3fe98a76a1d14c74a9e266d397cf6eb64be5e01/pytest-9.1.1.tar.gz", hash = "sha256:1088fbde8f2b49d95a549a195707afa7a76a3ce9bcadc26b6d71f0ffda5fe313", size = 1636369, upload-time = "2026-06-19T10:58:32.857Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/24/25/1de2678b631f5a49215c6c96fff41ba892b0a34df68d6d80292b1b48aa7f/pytest-9.1.1-py3-none-any.whl", hash = "sha256:37a86b45efb9a47a61a36449063e8e18d0cab3161329fc099eb21783169c4f0c", size = 386536, upload-time = "2026-06-19T10:58:31.347Z" },
+]