reasonwork 0.4.0__py3-none-any.whl

reasonwork_exchange/cli/sync.py

@@ -0,0 +1,317 @@
+"""`reasonwork sync` — bulk-submit newly discovered, consented sessions."""
+
+from __future__ import annotations
+
+import contextlib
+import fcntl
+import os
+import sys
+import time
+from collections import Counter
+from collections.abc import Iterator
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from pathlib import Path
+from typing import Annotated, Any
+
+import typer
+from rich.table import Table
+
+from reasonwork_exchange import version_check
+from reasonwork_exchange.config import ConsentConfigStore
+from reasonwork_exchange.errors import ConflictError, RemoteError
+from reasonwork_exchange.output import JsonOpt, console, emit, handle_errors
+from reasonwork_exchange.state import GrowthCandidate, SubmissionLedger
+
+_EPILOG = "example: reasonwork sync --limit 20 --concurrency 4"
+
+_MAX_UPLOAD_ATTEMPTS = 3
+_RATE_LIMIT_BACKOFF_SECONDS = 2.0
+
+
+def _sync_lock_path() -> Path:
+    return Path.home() / ".config" / "reasonwork" / "sync.lock"
+
+
+@contextlib.contextmanager
+def _try_acquire_sync_lock() -> Iterator[bool]:
+    """Yield True if this process holds the exclusive sync lock, else False without blocking.
+
+    A scheduled run and a manual run can otherwise overlap and race each other
+    writing to the submission ledger; the loser here skips instead of racing.
+    """
+    lock_path = _sync_lock_path()
+    lock_path.parent.mkdir(parents=True, exist_ok=True)
+    fd = os.open(lock_path, os.O_CREAT | os.O_RDWR, 0o600)
+    try:
+        fcntl.flock(fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
+    except BlockingIOError:
+        os.close(fd)
+        yield False
+        return
+    try:
+        yield True
+    finally:
+        fcntl.flock(fd, fcntl.LOCK_UN)
+        os.close(fd)
+
+
+def _submit_one(
+    path: Path,
+    *,
+    source: str,
+    token: str,
+    ledger: SubmissionLedger,
+    is_subagent: bool = False,
+    latest_version_sink: list[str] | None = None,
+) -> dict[str, Any]:
+    """Skip via the ledger when possible, otherwise analyze and submit one session."""
+    from reasonwork_exchange.analyzer import analyze
+    from reasonwork_exchange.client import ContributeClient
+
+    cached = ledger.cached_fingerprint(path)
+    if cached is not None:
+        # This path's own recorded status is authoritative for itself; status_for_hash
+        # is shared across any other path with identical content, so it must only be
+        # consulted as a fallback for a path that has no record of its own yet.
+        cached_status = ledger.last_recorded_status(path) or ledger.status_for_hash(cached.content_sha256)
+        if cached_status is not None:
+            return {"path": str(path), "source": source, "status": cached_status, "skipped": True}
+
+    # A live-captured session only grows from here (prior turns aren't retroactively
+    # scrubbed or rewritten), so every later poll would otherwise re-hash as "new"
+    # content and create another server record for what is really the same session.
+    # Once any outcome is recorded for this exact path, stop scanning and reporting
+    # it — unless it has since grown enough that the un-submitted tail is worth
+    # reconsidering, in which case fall through and re-analyze.
+    recorded_status = ledger.last_recorded_status(path)
+    growth: GrowthCandidate | None = None
+    if recorded_status is not None:
+        growth = ledger.growth_supersession(path, path.stat().st_size)
+        if growth is None:
+            return {"path": str(path), "source": source, "status": recorded_status, "skipped": True}
+
+    try:
+        analysis = analyze(path, discovered_source=source)
+    except (OSError, ValueError) as exc:
+        return {"path": str(path), "source": source, "status": "error", "detail": str(exc)}
+    # Codex subagent rollouts have no path signal (they sit alongside ordinary
+    # sessions, unlike Claude Code/Cursor's dedicated subagents/ folders), so
+    # discover()'s path-based guess is only ever a hint there; the analyzer's
+    # content-based determination is authoritative whenever it says True.
+    is_subagent = is_subagent or analysis.is_subagent
+
+    contained = ledger.find_contained_match(
+        path, content_sha256=analysis.content_sha256, byte_size=analysis.byte_size
+    )
+    if contained is not None:
+        report_id = None
+        try:
+            report_id = ContributeClient(token).report_local_duplicate(
+                path,
+                source=analysis.source or source,
+                analysis=analysis.to_dict(),
+                is_subagent=is_subagent,
+                duplicate_of_content_sha256=contained.content_sha256,
+            ).get("id")
+        except (RemoteError, ConflictError):
+            # Best-effort like report_local_rejection: the local skip stands either way.
+            pass
+        ledger.record(
+            path,
+            content_sha256=analysis.content_sha256,
+            byte_size=analysis.byte_size,
+            status="duplicate_content",
+            upload_id=report_id,
+        )
+        return {
+            "path": str(path),
+            "source": source,
+            "status": "duplicate_content",
+            "duplicate_of": str(contained.path),
+        }
+
+    redaction = None
+    if analysis.privacy_risk in {"medium", "high", "blocked"}:
+        from reasonwork_exchange.analyzer import redact_trajectory
+
+        redaction = redact_trajectory(path)
+        if not redaction.clean:
+            # Redaction couldn't fully clean the content (e.g. a PII shape our patterns
+            # don't cover) — fall back to the original hard rejection rather than risk
+            # uploading a partially-scrubbed file.
+            report_id = None
+            try:
+                report_id = ContributeClient(token).report_local_rejection(
+                    path, source=analysis.source or source, analysis=analysis.to_dict(), is_subagent=is_subagent
+                ).get("id")
+            except (RemoteError, ConflictError):
+                # Reporting the rejection is best-effort: the file never leaves this
+                # machine either way, so a network hiccup shouldn't block the local skip.
+                pass
+            ledger.record(
+                path,
+                content_sha256=analysis.content_sha256,
+                byte_size=analysis.byte_size,
+                status="rejected_privacy",
+                upload_id=report_id,
+            )
+            return {"path": str(path), "source": source, "status": "rejected_privacy", "risk": analysis.privacy_risk}
+
+    resolved_source = analysis.source or source
+    client = ContributeClient(token)
+    backoff = _RATE_LIMIT_BACKOFF_SECONDS
+
+    # The anti-gaming per-file checks live in analyzer.analyze(); this last check needs
+    # cross-submission history, which only the ledger has, so it's applied here instead.
+    analysis_payload = analysis.to_dict()
+    if redaction is not None:
+        # What's actually uploaded is the redacted body, so the metadata sent to the
+        # server must describe that body, not the original file on disk. The ledger
+        # below still records the original identity (content_sha256/byte_size of the
+        # file as it sits locally) since that's what growth/containment detection key
+        # off of; the redacted identity is only ever visible to the server.
+        analysis_payload["content_sha256"] = redaction.content_sha256
+        analysis_payload["byte_size"] = redaction.byte_size
+        analysis_payload["line_count"] = redaction.line_count
+    # The real score/price no longer get computed locally at all (see
+    # analyzer.analyze()'s own docstring/comment) -- deterministic_score is a
+    # neutral placeholder here, not a real number, so there's nothing
+    # meaningful to locally re-adjust for score-uniformity before submitting.
+    # The worker re-derives and applies that check itself, authoritatively.
+    submitted_score = analysis.deterministic_score
+
+    for attempt in range(_MAX_UPLOAD_ATTEMPTS):
+        try:
+            result = client.upload(
+                path,
+                source=resolved_source,
+                analysis=analysis_payload,
+                is_subagent=is_subagent,
+                supersedes_content_sha256=growth.uploaded_content_sha256 if growth else None,
+                superseded_byte_size=growth.byte_size if growth else None,
+                override_body=redaction.redacted_bytes if redaction is not None else None,
+                pii_redacted=redaction is not None,
+            )
+        except ConflictError:
+            ledger.record(
+                path, content_sha256=analysis.content_sha256, byte_size=analysis.byte_size, status="duplicate"
+            )
+            return {"path": str(path), "source": resolved_source, "status": "duplicate"}
+        except RemoteError as exc:
+            if exc.code == "upload_pending_operator_retry":
+                # Deliberately not recorded in the ledger: the row isn't
+                # resumable yet, but nothing about this path is permanent, so
+                # leave it unrecorded and let a future sync notice once an
+                # operator's retry flips the row back to "prepared".
+                return {"path": str(path), "source": resolved_source, "status": "pending_operator_retry"}
+            is_last_attempt = attempt == _MAX_UPLOAD_ATTEMPTS - 1
+            if exc.code != "contributor_rate_limited" or is_last_attempt:
+                return {"path": str(path), "source": resolved_source, "status": "error", "detail": exc.message}
+            time.sleep(backoff)
+            backoff *= 2
+            continue
+        if latest_version_sink is not None and result.get("latest_cli_version"):
+            latest_version_sink.append(result["latest_cli_version"])
+        ledger.record(
+            path,
+            content_sha256=analysis.content_sha256,
+            byte_size=analysis.byte_size,
+            status="submitted",
+            upload_id=result.get("id"),
+            score=submitted_score,
+            uploaded_content_sha256=analysis_payload["content_sha256"],
+        )
+        return {"path": str(path), "source": resolved_source, "status": "submitted", "id": result.get("id")}
+    return {"path": str(path), "source": resolved_source, "status": "error", "detail": "rate limit retries exhausted"}
+
+
+@handle_errors
+def sync(
+    limit: Annotated[int, typer.Option("--limit", min=1, max=2000, help="Newest local sessions to consider, per source.")] = 20,
+    concurrency: Annotated[int, typer.Option("--concurrency", min=1, max=16, help="Concurrent uploads.")] = 4,
+    dry_run: Annotated[bool, typer.Option("--dry-run", help="Report what would sync; submit nothing.")] = False,
+    yes: Annotated[bool, typer.Option("--yes", help="Skip the confirmation prompt under sharing_mode=ask.")] = False,
+    json_: JsonOpt = False,
+) -> int:
+    """Submit every newly discovered, consented session not already recorded in the ledger."""
+    from reasonwork_exchange.auth import ContributorAuthStore
+    from reasonwork_exchange.discovery import discover
+
+    consent = ConsentConfigStore().read()
+    if consent.sharing_mode == "none":
+        return emit(
+            json_,
+            {"synced": [], "total": 0, "skipped_reason": "sharing_mode_none"},
+            human="sharing_mode is 'none'; nothing to sync.",
+        )
+
+    # sharing_mode=ask means "ask a human before uploading" — it must never fall back
+    # to uploading unattended just because no one was there to answer the prompt. An
+    # unattended caller (the launchd timer, a cron job) has no controlling terminal, so
+    # detect that case up front and skip cleanly instead of letting typer.confirm's
+    # EOFError-turned-Abort silently enforce this by accident on every scheduled tick.
+    if not dry_run and consent.sharing_mode == "ask" and not yes and not sys.stdin.isatty():
+        return emit(
+            json_,
+            {"synced": [], "total": 0, "skipped_reason": "sharing_mode_ask_unattended"},
+            human="sharing_mode is 'ask' and no one is here to confirm; nothing to sync.",
+        )
+
+    candidates = [
+        item for item in discover(limit_per_source=limit) if not consent.is_excluded(item.source, item.path)
+    ]
+
+    if dry_run:
+        results = [
+            {
+                "path": str(item.path),
+                "source": item.source,
+                "is_subagent": item.is_subagent,
+                "status": "would_sync",
+            }
+            for item in candidates
+        ]
+    else:
+        if consent.sharing_mode == "ask" and not yes:
+            typer.confirm(f"Submit up to {len(candidates)} local session(s) to the exchange?", abort=True)
+        with _try_acquire_sync_lock() as acquired:
+            if not acquired:
+                return emit(
+                    json_,
+                    {"results": [], "counts": {}, "total": 0, "skipped_reason": "sync_in_progress"},
+                    human="another sync is already running; skipping.",
+                )
+            token = ContributorAuthStore().read()
+            ledger = SubmissionLedger()
+            results = []
+            latest_version_seen: list[str] = []
+            with ThreadPoolExecutor(max_workers=concurrency) as pool:
+                futures = [
+                    pool.submit(
+                        _submit_one,
+                        item.path,
+                        source=item.source,
+                        token=token,
+                        ledger=ledger,
+                        is_subagent=item.is_subagent,
+                        latest_version_sink=latest_version_seen,
+                    )
+                    for item in candidates
+                ]
+                for future in as_completed(futures):
+                    results.append(future.result())
+            # Best-effort update nudge, piggybacked off whatever this sync happened to
+            # upload/report -- there's no dedicated version-check endpoint. Skipped
+            # under --json so a stray notice line can't corrupt scripted stdout parsing.
+            if latest_version_seen and not json_:
+                notice = version_check.maybe_notice(latest_version_seen[0])
+                if notice:
+                    console.print(f"[yellow]{notice}[/yellow]")
+
+    counts = Counter(result["status"] for result in results)
+    table = Table(title="Sync results")
+    for heading in ("Status", "Count"):
+        table.add_column(heading)
+    for status, count in sorted(counts.items()):
+        table.add_row(status, str(count))
+    return emit(json_, {"results": results, "counts": dict(counts), "total": len(results)}, human=table)

reasonwork_exchange/cli/update.py

@@ -0,0 +1,177 @@
+"""`reasonwork update` -- pull/upgrade to the latest version, however it was installed.
+
+Two install paths exist and need two different update mechanisms:
+
+- Editable install from a local git checkout (`uv tool install --editable
+  ./tools/contributor-cli`) -- what the README documented before this package
+  was published to PyPI. "Update" means `git pull` the checkout, then
+  reinstall so any new dependencies/entry points take effect.
+- A real installed package (`pipx install reasonwork` or `uv tool
+  install reasonwork`, from PyPI) -- there's no git checkout to pull
+  at all. "Update" means asking whichever tool manager did the install to
+  upgrade it, since that's what actually knows how to fetch the newer
+  version and re-resolve dependencies.
+
+Which of these applies is detected automatically; a contributor never needs
+to know or specify which.
+"""
+
+from __future__ import annotations
+
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+from reasonwork_exchange.output import JsonOpt, emit_success, handle_errors
+
+_EPILOG = "example: reasonwork update"
+
+_MAX_PARENTS_TO_SEARCH = 6
+
+
+def _package_root() -> Path:
+    """Return the `tools/contributor-cli` directory this install's code lives in.
+
+    For an editable install, `reasonwork_exchange.__file__` resolves back to the
+    real source tree (not a copy), so this is the same path a contributor would
+    pass to `uv tool install --editable`.
+    """
+    import reasonwork_exchange
+
+    return Path(reasonwork_exchange.__file__).resolve().parents[2]
+
+
+def _git_repo_root(start: Path) -> Path | None:
+    current = start
+    for _ in range(_MAX_PARENTS_TO_SEARCH):
+        if (current / ".git").exists():
+            return current
+        if current.parent == current:
+            break
+        current = current.parent
+    return None
+
+
+def _installed_via() -> str:
+    """Guess which tool manager owns this install, from where its interpreter lives.
+
+    Both pipx and `uv tool install` give every tool its own isolated venv
+    named after the package, under a directory that names the manager itself
+    (`.../pipx/venvs/reasonwork/...` or `.../uv/tools/reasonwork/...`)
+    -- reliable across platforms without needing either tool's own APIs.
+    """
+    prefix = str(Path(sys.prefix).resolve())
+    if "pipx" in prefix:
+        return "pipx"
+    if "uv" in prefix and "tools" in prefix:
+        return "uv"
+    return "unknown"
+
+
+@handle_errors
+def update(
+    json_: JsonOpt = False,
+) -> int:
+    """Pull/upgrade to the latest CLI version, detecting how it was installed."""
+    package_root = _package_root()
+    repo_root = _git_repo_root(package_root)
+    if repo_root is not None:
+        return _update_from_git_checkout(json_, package_root, repo_root)
+    return _update_installed_package(json_)
+
+
+def _update_from_git_checkout(json_: bool, package_root: Path, repo_root: Path) -> int:
+    if shutil.which("git") is None or shutil.which("uv") is None:
+        return emit_success(
+            json_,
+            ["Both `git` and `uv` are required to self-update; install them and retry, or update manually."],
+            {"updated": False, "reason": "missing_git_or_uv"},
+        )
+
+    pull = subprocess.run(  # noqa: S603 - fixed argv, no shell, no user input
+        ["git", "-C", str(repo_root), "pull", "--ff-only"], capture_output=True, text=True, check=False
+    )
+    if pull.returncode != 0:
+        return emit_success(
+            json_,
+            [
+                "`git pull --ff-only` failed; resolve this manually in your checkout, then re-run `update`.",
+                (pull.stderr or pull.stdout).strip(),
+            ],
+            {"updated": False, "reason": "git_pull_failed", "detail": (pull.stderr or pull.stdout).strip()},
+        )
+
+    reinstall = subprocess.run(  # noqa: S603 - fixed argv, no shell, no user input
+        ["uv", "tool", "install", "--editable", str(package_root), "--reinstall"],
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    if reinstall.returncode != 0:
+        return emit_success(
+            json_,
+            [
+                "`git pull` succeeded but `uv tool install --reinstall` failed:",
+                (reinstall.stderr or reinstall.stdout).strip(),
+            ],
+            {
+                "updated": False,
+                "reason": "reinstall_failed",
+                "detail": (reinstall.stderr or reinstall.stdout).strip(),
+            },
+        )
+
+    return emit_success(
+        json_,
+        [
+            f"Pulled {repo_root} and reinstalled the CLI.",
+            "Run `reasonwork --version` to confirm the new version.",
+        ],
+        {"updated": True, "repo": str(repo_root)},
+    )
+
+
+def _update_installed_package(json_: bool) -> int:
+    manager = _installed_via()
+    if manager == "pipx":
+        command = ["pipx", "upgrade", "reasonwork"]
+    elif manager == "uv":
+        command = ["uv", "tool", "upgrade", "reasonwork"]
+    else:
+        return emit_success(
+            json_,
+            [
+                "Could not tell how this install was managed.",
+                "Try `pipx upgrade reasonwork` or `uv tool upgrade reasonwork` directly, "
+                "whichever you originally used to install it.",
+            ],
+            {"updated": False, "reason": "unknown_install_manager"},
+        )
+
+    if shutil.which(command[0]) is None:
+        return emit_success(
+            json_,
+            [f"`{command[0]}` was used to install this but isn't on PATH anymore; upgrade manually."],
+            {"updated": False, "reason": f"missing_{command[0]}"},
+        )
+
+    result = subprocess.run(command, capture_output=True, text=True, check=False)  # noqa: S603 - fixed argv
+    if result.returncode != 0:
+        return emit_success(
+            json_,
+            [f"`{' '.join(command)}` failed:", (result.stderr or result.stdout).strip()],
+            {"updated": False, "reason": "upgrade_failed", "detail": (result.stderr or result.stdout).strip()},
+        )
+
+    return emit_success(
+        json_,
+        [
+            f"Ran `{' '.join(command)}`.",
+            "Run `reasonwork --version` to confirm the new version.",
+        ],
+        {"updated": True, "via": manager},
+    )
+
+
+__all__ = ["update"]

reasonwork_exchange/cli/upload.py

@@ -0,0 +1,95 @@
+"""`reasonwork upload` — analyze and submit one selected session."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Annotated
+
+import typer
+
+from reasonwork_exchange.errors import ValidationError
+from reasonwork_exchange.output import JsonOpt, emit_success, handle_errors
+
+_EPILOG = (
+    "examples:\n"
+    "\n  reasonwork upload --path ~/.codex/sessions/2026/08/04/rollout.jsonl --dry-run"
+    "\n\n  reasonwork upload --path ~/.codex/sessions/2026/08/04/rollout.jsonl "
+    "--source codex --confirm-rights"
+)
+
+
+@handle_errors
+def upload(
+    path: Annotated[Path, typer.Option("--path", exists=True, dir_okay=False, readable=True)],
+    source: Annotated[
+        str, typer.Option("--source", help="codex, claude_code, cursor, or auto (detected from the file).")
+    ] = "auto",
+    confirm_rights: Annotated[
+        bool,
+        typer.Option(
+            "--confirm-rights", help="Reaffirm that you control the rights and removed secrets/confidential data."
+        ),
+    ] = False,
+    dry_run: Annotated[
+        bool, typer.Option("--dry-run", help="Analyze and price locally; upload nothing and make no network request.")
+    ] = False,
+    json_: JsonOpt = False,
+) -> int:
+    """Run safety checks and upload, or preview locally under --dry-run."""
+    if not confirm_rights and not dry_run:
+        raise ValidationError(
+            "rights confirmation is required for every submission",
+            code="rights_confirmation_required",
+            hint="review the file, then pass --confirm-rights",
+        )
+    if source not in {"auto", "codex", "claude_code", "cursor"}:
+        raise ValidationError("source must be auto, codex, claude_code, or cursor", code="invalid_source")
+
+    from reasonwork_exchange.analyzer import analyze
+    from reasonwork_exchange.auth import ContributorAuthStore
+    from reasonwork_exchange.client import ContributeClient
+
+    try:
+        analysis = analyze(path, discovered_source=None if source == "auto" else source)
+    except (OSError, ValueError) as exc:
+        raise ValidationError(str(exc), code="invalid_trajectory") from exc
+    resolved_source = analysis.source if source == "auto" else source
+    if resolved_source is None:
+        raise ValidationError("could not identify this as a Codex, Claude Code, or Cursor session", code="unknown_source")
+    if analysis.source and analysis.source != resolved_source:
+        raise ValidationError(f"file looks like {analysis.source}, not {resolved_source}", code="source_mismatch")
+    if analysis.privacy_risk in {"medium", "high", "blocked"}:
+        raise ValidationError(
+            "local privacy scan found secrets or personal data; redact before uploading",
+            code="privacy_scan_failed",
+            details={"risk": analysis.privacy_risk, "findings": analysis.secret_findings},
+        )
+    # Score and price are no longer computed locally at all (see
+    # analyzer.analyze()'s own docstring) -- only the server, after actually
+    # re-downloading and reviewing the content, knows what a session is worth.
+    if dry_run:
+        return emit_success(
+            json_,
+            [
+                f"[dry-run] would submit {path.name} as {resolved_source}; no network request made.",
+                f"{analysis.message_count} messages, {analysis.tool_call_count} tool calls. "
+                "Score and price are determined server-side after review.",
+            ],
+            {
+                "submitted": False,
+                "dry_run": True,
+                "would_submit": {"path": str(path), "source": resolved_source},
+                "analysis": analysis.to_dict(),
+            },
+        )
+    token = ContributorAuthStore().read()
+    result = ContributeClient(token).upload(path, source=resolved_source, analysis=analysis.to_dict())
+    return emit_success(
+        json_,
+        [
+            f"Submitted {path.name} for review.",
+            f"{analysis.message_count} messages, {analysis.tool_call_count} tool calls. "
+            "Score and price are determined server-side after review.",
+        ],
+        {"submitted": True, "id": result.get("id"), "status": result.get("status"), "analysis": analysis.to_dict()},
+    )