reasonwork 0.4.0__py3-none-any.whl

reasonwork_exchange/auth.py

@@ -0,0 +1,47 @@
+"""Owner-only local storage for the contributor upload token."""
+
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+
+from reasonwork_exchange.errors import AuthError, ValidationError
+
+
+class ContributorAuthStore:
+    """Persist a raw nxc_ contributor token separately from internal PATs."""
+
+    def __init__(self, path: Path | None = None) -> None:
+        """Use an explicit path or the contributor-only config location."""
+        self.path = path or (Path.home() / ".config" / "reasonwork" / "exchange-auth.json")
+
+    def write(self, token: str) -> None:
+        """Write one validated contributor token with mode 600."""
+        if not token.startswith("nxc_"):
+            raise ValidationError("expected an nxc_ contributor token", code="invalid_contributor_token")
+        self.path.parent.mkdir(parents=True, exist_ok=True)
+        fd = os.open(self.path, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)
+        with os.fdopen(fd, "w") as handle:
+            os.fchmod(handle.fileno(), 0o600)
+            handle.write(json.dumps({"schema_version": 1, "token": token}, indent=2) + "\n")
+
+    def read(self) -> str:
+        """Read the env override or stored token."""
+        env_token = os.environ.get("REASONWORK_EXCHANGE_TOKEN")
+        if env_token:
+            return env_token
+        try:
+            token = json.loads(self.path.read_text())["token"]
+        except (OSError, KeyError, json.JSONDecodeError) as exc:
+            raise AuthError(
+                "not logged in as a contributor",
+                code="no_contributor_token",
+                hint=(
+                    "create a token at https://ce-staging.collinear.dev/settings, "
+                    "then run `reasonwork login --token nxc_…`"
+                ),
+            ) from exc
+        if not isinstance(token, str) or not token.startswith("nxc_"):
+            raise AuthError("stored contributor token is invalid", code="invalid_contributor_token")
+        return token

reasonwork_exchange/cli/__init__.py

@@ -0,0 +1,55 @@
+"""Command tree for the standalone Reasonwork CLI (by ReasonworkAI)."""
+
+from __future__ import annotations
+
+from typing import Annotated
+
+import typer
+
+from reasonwork_exchange import __version__
+from reasonwork_exchange.cli import config as _config
+from reasonwork_exchange.cli import login as _login
+from reasonwork_exchange.cli import scan as _scan
+from reasonwork_exchange.cli import schedule as _schedule
+from reasonwork_exchange.cli import sync as _sync
+from reasonwork_exchange.cli import update as _update
+from reasonwork_exchange.cli import upload as _upload
+
+app = typer.Typer(
+    name="reasonwork",
+    help="Discover, inspect, and submit Codex or Claude Code trajectories.",
+    add_completion=False,
+    rich_markup_mode="rich",
+    no_args_is_help=True,
+)
+
+app.command(name="login", epilog=_login._EPILOG)(_login.login)
+app.command(name="scan", epilog=_scan._EPILOG)(_scan.scan)
+app.command(name="sync", epilog=_sync._EPILOG)(_sync.sync)
+app.command(name="upload", epilog=_upload._EPILOG)(_upload.upload)
+app.command(name="update", epilog=_update._EPILOG)(_update.update)
+app.add_typer(_config.config_app)
+app.add_typer(_schedule.schedule_app)
+
+
+def _version(value: bool) -> None:
+    if value:
+        typer.echo(__version__)
+        raise typer.Exit()
+
+
+@app.callback()
+def main(
+    version: Annotated[
+        bool, typer.Option("--version", callback=_version, is_eager=True, help="Show the installed CLI version.")
+    ] = False,
+) -> None:
+    """Run the contributor exchange CLI."""
+
+
+def entrypoint() -> None:
+    """Console-script entry point."""
+    app()
+
+
+__all__ = ["app", "entrypoint", "main"]

reasonwork_exchange/cli/config.py

@@ -0,0 +1,89 @@
+"""`reasonwork config` — inspect and adjust local sharing consent."""
+
+from __future__ import annotations
+
+from dataclasses import replace
+from typing import Annotated
+
+import typer
+
+from reasonwork_exchange.config import VALID_SHARING_MODES, ConsentConfigStore
+from reasonwork_exchange.errors import ValidationError
+from reasonwork_exchange.output import JsonOpt, emit_success, handle_errors
+
+_EPILOG = "example: reasonwork config set --sharing-mode ask"
+
+config_app = typer.Typer(name="config", help="Inspect and adjust local sharing consent.", no_args_is_help=True)
+
+
+@handle_errors
+def show(json_: JsonOpt = False) -> int:
+    """Print the current consent settings."""
+    config = ConsentConfigStore().read()
+    return emit_success(
+        json_,
+        [
+            f"sharing_mode: {config.sharing_mode}",
+            f"excluded_sources: {', '.join(config.excluded_sources) or '(none)'}",
+            f"excluded_paths: {', '.join(config.excluded_paths) or '(none)'}",
+        ],
+        {
+            "sharing_mode": config.sharing_mode,
+            "excluded_sources": config.excluded_sources,
+            "excluded_paths": config.excluded_paths,
+        },
+    )
+
+
+@handle_errors
+def set_mode(
+    sharing_mode: Annotated[str, typer.Option("--sharing-mode", help="all, ask, or none.")],
+    json_: JsonOpt = False,
+) -> int:
+    """Set the sharing mode: all, ask, or none."""
+    if sharing_mode not in VALID_SHARING_MODES:
+        raise ValidationError(
+            f"sharing mode must be one of {', '.join(sorted(VALID_SHARING_MODES))}", code="invalid_sharing_mode"
+        )
+    store = ConsentConfigStore()
+    store.write(replace(store.read(), sharing_mode=sharing_mode))
+    return emit_success(json_, [f"sharing_mode set to {sharing_mode}."], {"sharing_mode": sharing_mode})
+
+
+@handle_errors
+def exclude(
+    source: Annotated[str | None, typer.Option("--source", help="Source name to exclude, e.g. codex.")] = None,
+    path: Annotated[str | None, typer.Option("--path", help="Path prefix to exclude.")] = None,
+    remove: Annotated[bool, typer.Option("--remove", help="Remove instead of add the given exclusion.")] = False,
+    json_: JsonOpt = False,
+) -> int:
+    """Add or remove a source or path exclusion from local sharing."""
+    if not source and not path:
+        raise ValidationError("pass --source or --path", code="missing_exclusion_target")
+    store = ConsentConfigStore()
+    config = store.read()
+    excluded_sources = list(config.excluded_sources)
+    excluded_paths = list(config.excluded_paths)
+    if source:
+        if remove:
+            excluded_sources = [item for item in excluded_sources if item != source]
+        elif source not in excluded_sources:
+            excluded_sources.append(source)
+    if path:
+        if remove:
+            excluded_paths = [item for item in excluded_paths if item != path]
+        elif path not in excluded_paths:
+            excluded_paths.append(path)
+    store.write(replace(config, excluded_sources=excluded_sources, excluded_paths=excluded_paths))
+    return emit_success(
+        json_,
+        [f"{'removed' if remove else 'added'} exclusion."],
+        {"excluded_sources": excluded_sources, "excluded_paths": excluded_paths},
+    )
+
+
+config_app.command(name="show")(show)
+config_app.command(name="set", epilog=_EPILOG)(set_mode)
+config_app.command(name="exclude")(exclude)
+
+__all__ = ["config_app"]

reasonwork_exchange/cli/login.py

@@ -0,0 +1,39 @@
+"""`reasonwork login` — verify and store a contributor token."""
+
+from __future__ import annotations
+
+from typing import Annotated
+
+import typer
+
+from reasonwork_exchange.output import JsonOpt, emit_success, handle_errors
+
+_EPILOG = "example: reasonwork login --token nxc_xxx --dry-run"
+
+
+@handle_errors
+def login(
+    token: Annotated[str, typer.Option("--token", help="The nxc_ token created in the exchange's /settings page.")],
+    dry_run: Annotated[
+        bool, typer.Option("--dry-run", help="Verify the token but do not write the contributor auth file.")
+    ] = False,
+    json_: JsonOpt = False,
+) -> int:
+    """Verify the token and store it, or preview under --dry-run."""
+    from reasonwork_exchange.auth import ContributorAuthStore
+    from reasonwork_exchange.client import ContributeClient
+
+    identity = ContributeClient(token).whoami()
+    store = ContributorAuthStore()
+    if not dry_run:
+        store.write(token)
+    email = str(identity.get("email", ""))
+    return emit_success(
+        json_,
+        (
+            [f"[dry-run] verified contributor {email}; token file was not written."]
+            if dry_run
+            else [f"Logged in as contributor {email}.", f"Token stored at {store.path} (mode 600)."]
+        ),
+        {"logged_in": not dry_run, "verified": True, "dry_run": dry_run, "email": email, "path": str(store.path)},
+    )

reasonwork_exchange/cli/scan.py

@@ -0,0 +1,99 @@
+"""`reasonwork scan` — preview local trajectory candidates safely."""
+
+from __future__ import annotations
+
+from typing import Annotated, Any
+
+import typer
+from rich.table import Table
+
+from reasonwork_exchange.output import JsonOpt, emit, handle_errors
+
+_EPILOG = "example: reasonwork scan --limit 20"
+
+
+@handle_errors
+def scan(
+    limit: Annotated[int, typer.Option("--limit", min=1, max=500, help="Newest candidates to inspect, per source.")] = 20,
+    json_: JsonOpt = False,
+) -> int:
+    """Discover local Codex and Claude Code sessions and show metadata-only checks."""
+    from reasonwork_exchange.analyzer import analyze
+    from reasonwork_exchange.discovery import discover
+    from reasonwork_exchange.state import SubmissionLedger
+
+    ledger = SubmissionLedger()
+    results: list[dict[str, Any]] = []
+    for item in discover(limit_per_source=limit):
+        cached = ledger.cached_fingerprint(item.path)
+        cached_status = ledger.status_for_hash(cached.content_sha256) if cached else None
+        if cached_status is not None:
+            results.append(
+                {
+                    "path": str(item.path),
+                    "discovered_source": item.source,
+                    "is_subagent": item.is_subagent,
+                    "status": cached_status,
+                    "skipped": True,
+                }
+            )
+            continue
+
+        # A live-captured session only grows by appending, so a large
+        # actively-growing file would otherwise fail cached_fingerprint (an
+        # exact mtime/size match) on every single poll, paying for a full
+        # secret/PII re-scan of the whole file each time. This reuses the
+        # same not-worth-reconsidering-yet growth threshold sync's
+        # _submit_one already applies before calling analyze() — scan is a
+        # read-only preview, so it can safely skip the same way sync does.
+        recorded_status = ledger.last_recorded_status(item.path)
+        if recorded_status is not None:
+            byte_size = item.path.stat().st_size
+            if ledger.growth_supersession(item.path, byte_size) is None:
+                results.append(
+                    {
+                        "path": str(item.path),
+                        "discovered_source": item.source,
+                        "is_subagent": item.is_subagent,
+                        "status": recorded_status,
+                        "skipped": True,
+                    }
+                )
+                continue
+        try:
+            analysis = analyze(item.path, discovered_source=item.source).to_dict()
+            # Codex subagents have no path signal (see sync.py's _submit_one for the
+            # same merge) -- the analyzer's content-based determination is
+            # authoritative whenever it says True.
+            analysis["is_subagent"] = item.is_subagent or analysis["is_subagent"]
+            results.append(
+                {"path": str(item.path), "discovered_source": item.source, **analysis}
+            )
+        except (OSError, ValueError) as exc:
+            results.append(
+                {
+                    "path": str(item.path),
+                    "discovered_source": item.source,
+                    "is_subagent": item.is_subagent,
+                    "error": str(exc),
+                    "estimated_cents": 0,
+                }
+            )
+
+    table = Table(title="Local trajectory candidates")
+    for heading in ("Source", "Risk", "Messages", "Tool calls", "Session file"):
+        table.add_column(heading)
+    for row in results:
+        # Score/price are no longer computed locally at all (see analyzer.analyze()'s
+        # own docstring) -- only the server, after actual review, knows what a
+        # session is worth. Message/tool-call counts are still genuinely local
+        # signals worth previewing (e.g. spotting an empty or read-only session
+        # before bothering to submit it).
+        table.add_row(
+            str(row.get("source") or row["discovered_source"]),
+            str(row.get("privacy_risk") or "skipped"),
+            "—" if "message_count" not in row else str(row["message_count"]),
+            "—" if "tool_call_count" not in row else str(row["tool_call_count"]),
+            str(row["path"]),
+        )
+    return emit(json_, {"candidates": results, "total": len(results)}, human=table)

reasonwork_exchange/cli/schedule.py

@@ -0,0 +1,140 @@
+"""`reasonwork schedule` — manage a background agent that runs `sync` on a timer."""
+
+from __future__ import annotations
+
+import platform
+import subprocess
+import sys
+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 = "example: reasonwork schedule install --interval-minutes 30"
+
+_LABEL = "ai.reasonwork.contributor-exchange.sync"
+_DEFAULT_INTERVAL_MINUTES = 10
+
+schedule_app = typer.Typer(name="schedule", help="Manage automatic background sync.", no_args_is_help=True)
+
+
+def _plist_path() -> Path:
+    return Path.home() / "Library" / "LaunchAgents" / f"{_LABEL}.plist"
+
+
+def _log_path() -> Path:
+    return Path.home() / ".config" / "reasonwork" / "sync.log"
+
+
+def _require_macos() -> None:
+    if platform.system() != "Darwin":
+        raise ValidationError(
+            "background scheduling is only wired up for macOS launchd",
+            code="unsupported_platform",
+            hint="on Linux, add a systemd timer or cron entry that runs 'reasonwork sync' on your own schedule",
+        )
+
+
+def _render_plist(*, interval_minutes: int, python_executable: str) -> str:
+    return (
+        '<?xml version="1.0" encoding="UTF-8"?>\n'
+        '<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">\n'
+        '<plist version="1.0">\n'
+        "<dict>\n"
+        "    <key>Label</key>\n"
+        f"    <string>{_LABEL}</string>\n"
+        "    <key>ProgramArguments</key>\n"
+        "    <array>\n"
+        f"        <string>{python_executable}</string>\n"
+        "        <string>-m</string>\n"
+        "        <string>reasonwork_exchange</string>\n"
+        "        <string>sync</string>\n"
+        "        <string>--json</string>\n"
+        "    </array>\n"
+        "    <key>StartInterval</key>\n"
+        f"    <integer>{interval_minutes * 60}</integer>\n"
+        "    <key>StandardOutPath</key>\n"
+        f"    <string>{_log_path()}</string>\n"
+        "    <key>StandardErrorPath</key>\n"
+        f"    <string>{_log_path()}</string>\n"
+        "    <key>RunAtLoad</key>\n"
+        "    <false/>\n"
+        "</dict>\n"
+        "</plist>\n"
+    )
+
+
+@handle_errors
+def install(
+    interval_minutes: Annotated[
+        int, typer.Option("--interval-minutes", min=1, max=1440, help="How often to run sync.")
+    ] = _DEFAULT_INTERVAL_MINUTES,
+    yes: Annotated[bool, typer.Option("--yes", help="Skip the confirmation prompt.")] = False,
+    json_: JsonOpt = False,
+) -> int:
+    """Install (or replace) the per-user launchd agent that runs sync on a timer."""
+    _require_macos()
+    if not yes:
+        typer.confirm(
+            f"Install a background agent that runs `sync` every {interval_minutes} minute(s)? "
+            "(only auto-uploads while sharing_mode=all; sharing_mode=ask sessions are left for interactive review)",
+            abort=True,
+        )
+    plist_path = _plist_path()
+    plist_path.parent.mkdir(parents=True, exist_ok=True)
+    _log_path().parent.mkdir(parents=True, exist_ok=True)
+
+    if plist_path.exists():
+        subprocess.run(["launchctl", "unload", str(plist_path)], check=False, capture_output=True)
+
+    plist_path.write_text(_render_plist(interval_minutes=interval_minutes, python_executable=sys.executable))
+    subprocess.run(["launchctl", "load", str(plist_path)], check=True, capture_output=True)
+
+    return emit_success(
+        json_,
+        [f"Installed background sync every {interval_minutes} minute(s).", f"Logs: {_log_path()}"],
+        {"installed": True, "interval_minutes": interval_minutes, "plist_path": str(plist_path)},
+    )
+
+
+@handle_errors
+def uninstall(json_: JsonOpt = False) -> int:
+    """Remove the background sync agent, if one is installed."""
+    _require_macos()
+    plist_path = _plist_path()
+    if not plist_path.exists():
+        return emit_success(json_, ["No background sync agent was installed."], {"removed": False})
+    subprocess.run(["launchctl", "unload", str(plist_path)], check=False, capture_output=True)
+    plist_path.unlink()
+    return emit_success(json_, ["Removed background sync agent."], {"removed": True})
+
+
+@handle_errors
+def status(json_: JsonOpt = False) -> int:
+    """Report whether the background sync agent is installed and loaded."""
+    _require_macos()
+    plist_path = _plist_path()
+    installed = plist_path.exists()
+    loaded = False
+    if installed:
+        result = subprocess.run(["launchctl", "list", _LABEL], check=False, capture_output=True)
+        loaded = result.returncode == 0
+    lines = [f"installed: {installed}", f"loaded: {loaded}"]
+    if installed:
+        lines.append(f"plist: {plist_path}")
+        lines.append(f"log: {_log_path()}")
+    return emit_success(
+        json_,
+        lines,
+        {"installed": installed, "loaded": loaded, "plist_path": str(plist_path) if installed else None},
+    )
+
+
+schedule_app.command(name="install", epilog=_EPILOG)(install)
+schedule_app.command(name="uninstall")(uninstall)
+schedule_app.command(name="status")(status)
+
+__all__ = ["schedule_app"]