logion-cli 0.1.0__py3-none-any.whl

cli/commands/bounties.py

@@ -0,0 +1,490 @@
+# SPDX-License-Identifier: MIT
+"""Bounties commands — create, list, get, lifecycle, submissions."""
+
+from __future__ import annotations
+
+import argparse
+import json
+from datetime import datetime
+from pathlib import Path
+
+from cli._config import resolve_config_from_args
+from cli._confirm import require_yes
+from cli._context import make_client
+from cli._errors import (
+    handle_error,
+    print_err,
+    validate_uuid_id,
+)
+from cli._options import COMMON_PARSER
+from cli._output import emit, emit_json, to_data
+from cli._utils import only_not_none
+from cli.commands import workspace as _workspace
+
+
+def parse_datetime(value: str | None) -> datetime | None:
+    """Parse an ISO-8601 datetime string, treating trailing Z as UTC."""
+    if value is None:
+        return None
+    return datetime.fromisoformat(value.replace("Z", "+00:00"))
+
+
+def load_evidence(path: Path | None) -> dict[str, object] | None:
+    """Load a JSON evidence file, returning None if *path* is None.
+
+    Returns ``None`` and prints a user-facing error when the file
+    is missing or contains invalid JSON.
+    """
+    if path is None:
+        return None
+    try:
+        return json.loads(path.read_text())  # type: ignore[no-any-return]
+    except (OSError, json.JSONDecodeError) as exc:
+        print_err(f"Error: evidence JSON must be valid: {exc}")
+        return None
+
+
+def register(subparsers: argparse._SubParsersAction) -> None:
+    """Register the ``bounties`` subcommand group."""
+    parser = subparsers.add_parser(
+        "bounties",
+        help="Manage bounties",
+    )
+    sub = parser.add_subparsers(
+        dest="bounties_command",
+        required=True,
+    )
+
+    # ── create ──────────────────────────────────────────────────
+    create = sub.add_parser(
+        "create",
+        help="Create a new bounty",
+        parents=[COMMON_PARSER],
+    )
+    create.add_argument("--course-id", required=True)
+    create.add_argument("--title", required=True)
+    create.add_argument("--description", required=True)
+    create.add_argument("--reward-cents", required=True, type=int)
+    create.add_argument("--currency")
+    create.add_argument("--submission-deadline")
+    create.set_defaults(handler=handle_create)
+
+    # ── list ────────────────────────────────────────────────────
+    ls = sub.add_parser(
+        "list",
+        help="List bounties",
+        parents=[COMMON_PARSER],
+    )
+    ls.add_argument("--scope", choices=["mine", "open", "funded"])
+    ls.set_defaults(handler=handle_list)
+
+    # ── get ──────────────────────────────────────────────────────
+    get = sub.add_parser(
+        "get",
+        help="Get bounty details",
+        parents=[COMMON_PARSER],
+    )
+    get.add_argument("bounty_id", metavar="BOUNTY_ID")
+    get.set_defaults(handler=handle_get)
+
+    # ── lifecycle commands (open / fund / cancel) ───────────────
+    # `logion bounties payout` is gone — accept accrues a
+    # creator-payable balance directly, and contributors cash out via
+    # `logion payments cash-out`. No separate payout step.
+    for cmd, sdk_method, action in [
+        ("open", "update_status", "open this bounty"),
+        (
+            "fund",
+            "update_funding",
+            "fund this bounty (credits will be debited)",
+        ),
+        ("cancel", "delete", "cancel this bounty"),
+    ]:
+        p = sub.add_parser(
+            cmd,
+            help=f"{cmd.capitalize()} a bounty",
+            parents=[COMMON_PARSER],
+        )
+        p.add_argument("bounty_id", metavar="BOUNTY_ID")
+        p.add_argument("--yes", action="store_true")
+        handler = _make_lifecycle_handler(cmd, sdk_method, action)
+        p.set_defaults(handler=handler)
+
+    # ── submissions sub-group ────────────────────────────────────
+    submissions = sub.add_parser(
+        "submissions",
+        help="Manage bounty submissions",
+    )
+    sub_sub = submissions.add_subparsers(
+        dest="bounties_submissions_command",
+        required=True,
+    )
+
+    # submissions create
+    sc = sub_sub.add_parser(
+        "create",
+        help="Create a submission for a bounty",
+        parents=[COMMON_PARSER],
+    )
+    sc.add_argument("bounty_id", metavar="BOUNTY_ID")
+    sc.add_argument("--title", required=True)
+    sc.add_argument("--description")
+    sc.add_argument("--evidence-json", type=Path, metavar="PATH")
+    sc.add_argument("--proposed-course-version-id")
+    sc.set_defaults(handler=handle_submissions_create)
+
+    # submissions list
+    sl = sub_sub.add_parser(
+        "list",
+        help="List submissions for a bounty",
+        parents=[COMMON_PARSER],
+    )
+    sl.add_argument("bounty_id", metavar="BOUNTY_ID")
+    sl.set_defaults(handler=handle_submissions_list)
+
+    # submissions get
+    sg = sub_sub.add_parser(
+        "get",
+        help="Get submission details",
+        parents=[COMMON_PARSER],
+    )
+    sg.add_argument("bounty_id", metavar="BOUNTY_ID")
+    sg.add_argument("submission_id", metavar="SUBMISSION_ID")
+    sg.set_defaults(handler=handle_submissions_get)
+
+    # submissions accept
+    sa = sub_sub.add_parser(
+        "accept",
+        help="Accept a submission",
+        parents=[COMMON_PARSER],
+    )
+    sa.add_argument("bounty_id", metavar="BOUNTY_ID")
+    sa.add_argument("submission_id", metavar="SUBMISSION_ID")
+    sa.add_argument("--yes", action="store_true")
+    sa.set_defaults(handler=handle_submissions_accept)
+
+    # submissions reject
+    sr = sub_sub.add_parser(
+        "reject",
+        help="Reject a submission",
+        parents=[COMMON_PARSER],
+    )
+    sr.add_argument("bounty_id", metavar="BOUNTY_ID")
+    sr.add_argument("submission_id", metavar="SUBMISSION_ID")
+    sr.add_argument("--yes", action="store_true")
+    sr.set_defaults(handler=handle_submissions_reject)
+
+    # submissions withdraw
+    sw = sub_sub.add_parser(
+        "withdraw",
+        help="Withdraw a submission",
+        parents=[COMMON_PARSER],
+    )
+    sw.add_argument("bounty_id", metavar="BOUNTY_ID")
+    sw.add_argument("submission_id", metavar="SUBMISSION_ID")
+    sw.add_argument("--yes", action="store_true")
+    sw.set_defaults(handler=handle_submissions_withdraw)
+
+    # ── workspace sub-group ──────────────────────────────────────
+    _workspace.register(sub)
+
+
+# ── Lifecycle handler factory ────────────────────────────────────
+
+
+def _make_lifecycle_handler(cmd: str, sdk_method: str, action: str):
+    """Return a handler function for a bounty lifecycle command."""
+
+    def handler(args: argparse.Namespace) -> int:
+        bad_id = validate_uuid_id(args.bounty_id, "BOUNTY_ID")
+        if bad_id is not None:
+            return bad_id
+        refusal = require_yes(args.yes, action)
+        if refusal is not None:
+            return refusal
+        config = resolve_config_from_args(args)
+        client = make_client(config)
+        try:
+            method = getattr(client.v1.bounties, sdk_method)
+            result = method(bounty_id=args.bounty_id)
+            emit(result, json_output=config.json_output)
+        except Exception as exc:
+            return handle_error(exc)
+        else:
+            return 0
+        finally:
+            client.close()
+
+    handler.__name__ = f"handle_{cmd}"
+    handler.__doc__ = f"Execute the bounties {cmd} command."
+    return handler
+
+
+# ── Handlers ──────────────────────────────────────────────────────
+
+
+def handle_create(args: argparse.Namespace) -> int:
+    """Execute the bounties create command."""
+    bad_id = validate_uuid_id(args.course_id, "--course-id")
+    if bad_id is not None:
+        return bad_id
+    # Validate --submission-deadline format early
+    if args.submission_deadline is not None:
+        try:
+            parse_datetime(args.submission_deadline)
+        except (ValueError, TypeError) as exc:
+            print_err(f"Error: --submission-deadline: {exc}")
+            return 2
+    config = resolve_config_from_args(args)
+    client = make_client(config)
+    try:
+        kwargs = only_not_none(
+            {
+                "course_id": args.course_id,
+                "title": args.title,
+                "description": args.description,
+                "reward_amount_cents": args.reward_cents,
+            },
+            currency=args.currency,
+            submission_deadline=parse_datetime(args.submission_deadline),
+        )
+        result = client.v1.bounties.create(**kwargs)
+        emit(result, json_output=config.json_output)
+    except Exception as exc:
+        return handle_error(exc)
+    else:
+        return 0
+    finally:
+        client.close()
+
+
+def handle_list(args: argparse.Namespace) -> int:
+    """Execute the bounties list command."""
+    config = resolve_config_from_args(args)
+    client = make_client(config)
+    try:
+        kwargs = only_not_none(
+            {},
+            scope=args.scope,
+        )
+        result = client.v1.bounties.list(**kwargs)
+        if config.json_output:
+            data = (
+                result.model_dump(mode="json")
+                if hasattr(result, "model_dump")
+                else to_data(result)
+            )
+            emit_json("logion.bounties.list", data)
+        else:
+            emit(result, json_output=False)
+    except Exception as exc:
+        return handle_error(exc)
+    else:
+        return 0
+    finally:
+        client.close()
+
+
+def handle_get(args: argparse.Namespace) -> int:
+    """Execute the bounties get command."""
+    bad_id = validate_uuid_id(args.bounty_id, "BOUNTY_ID")
+    if bad_id is not None:
+        return bad_id
+    config = resolve_config_from_args(args)
+    client = make_client(config)
+    try:
+        result = client.v1.bounties.get(bounty_id=args.bounty_id)
+        if config.json_output:
+            data = (
+                result.model_dump(mode="json")
+                if hasattr(result, "model_dump")
+                else to_data(result)
+            )
+            emit_json("logion.bounties.get", data)
+        else:
+            emit(result, json_output=False)
+    except Exception as exc:
+        return handle_error(exc)
+    else:
+        return 0
+    finally:
+        client.close()
+
+
+# ── Submission handlers ──────────────────────────────────────────
+
+
+def handle_submissions_create(args: argparse.Namespace) -> int:
+    """Execute the bounties submissions create command."""
+    bad_id = validate_uuid_id(args.bounty_id, "BOUNTY_ID")
+    if bad_id is not None:
+        return bad_id
+    if args.proposed_course_version_id is not None:
+        bad_id = validate_uuid_id(
+            args.proposed_course_version_id,
+            "--proposed-course-version-id",
+        )
+        if bad_id is not None:
+            return bad_id
+    evidence = load_evidence(args.evidence_json)
+    if args.evidence_json is not None and evidence is None:
+        return 2
+    config = resolve_config_from_args(args)
+    client = make_client(config)
+    try:
+        kwargs = only_not_none(
+            {
+                "bounty_id": args.bounty_id,
+                "title": args.title,
+            },
+            description=args.description,
+            evidence=evidence,
+            proposed_course_version_id=args.proposed_course_version_id,
+        )
+        result = client.v1.bounties.create_submission(**kwargs)
+        emit(result, json_output=config.json_output)
+    except Exception as exc:
+        return handle_error(exc)
+    else:
+        return 0
+    finally:
+        client.close()
+
+
+def handle_submissions_list(args: argparse.Namespace) -> int:
+    """Execute the bounties submissions list command."""
+    bad_id = validate_uuid_id(args.bounty_id, "BOUNTY_ID")
+    if bad_id is not None:
+        return bad_id
+    config = resolve_config_from_args(args)
+    client = make_client(config)
+    try:
+        result = client.v1.bounties.list_submissions(bounty_id=args.bounty_id)
+        if config.json_output:
+            data = (
+                result.model_dump(mode="json")
+                if hasattr(result, "model_dump")
+                else to_data(result)
+            )
+            emit_json("logion.bounties.submissions.list", data)
+        else:
+            emit(result, json_output=False)
+    except Exception as exc:
+        return handle_error(exc)
+    else:
+        return 0
+    finally:
+        client.close()
+
+
+def handle_submissions_get(args: argparse.Namespace) -> int:
+    """Execute the bounties submissions get command."""
+    bad_id = validate_uuid_id(args.bounty_id, "BOUNTY_ID")
+    if bad_id is not None:
+        return bad_id
+    bad_id = validate_uuid_id(args.submission_id, "SUBMISSION_ID")
+    if bad_id is not None:
+        return bad_id
+    config = resolve_config_from_args(args)
+    client = make_client(config)
+    try:
+        result = client.v1.bounties.get_submission(
+            bounty_id=args.bounty_id,
+            submission_id=args.submission_id,
+        )
+        if config.json_output:
+            data = (
+                result.model_dump(mode="json")
+                if hasattr(result, "model_dump")
+                else to_data(result)
+            )
+            emit_json("logion.bounties.submissions.get", data)
+        else:
+            emit(result, json_output=False)
+    except Exception as exc:
+        return handle_error(exc)
+    else:
+        return 0
+    finally:
+        client.close()
+
+
+def handle_submissions_accept(args: argparse.Namespace) -> int:
+    """Execute the bounties submissions accept command."""
+    bad_id = validate_uuid_id(args.bounty_id, "BOUNTY_ID")
+    if bad_id is not None:
+        return bad_id
+    bad_id = validate_uuid_id(args.submission_id, "SUBMISSION_ID")
+    if bad_id is not None:
+        return bad_id
+    refusal = require_yes(args.yes, "accept this submission")
+    if refusal is not None:
+        return refusal
+    config = resolve_config_from_args(args)
+    client = make_client(config)
+    try:
+        result = client.v1.bounties.accept_submission(
+            bounty_id=args.bounty_id,
+            submission_id=args.submission_id,
+        )
+        emit(result, json_output=config.json_output)
+    except Exception as exc:
+        return handle_error(exc)
+    else:
+        return 0
+    finally:
+        client.close()
+
+
+def handle_submissions_reject(args: argparse.Namespace) -> int:
+    """Execute the bounties submissions reject command."""
+    bad_id = validate_uuid_id(args.bounty_id, "BOUNTY_ID")
+    if bad_id is not None:
+        return bad_id
+    bad_id = validate_uuid_id(args.submission_id, "SUBMISSION_ID")
+    if bad_id is not None:
+        return bad_id
+    refusal = require_yes(args.yes, "reject this submission")
+    if refusal is not None:
+        return refusal
+    config = resolve_config_from_args(args)
+    client = make_client(config)
+    try:
+        result = client.v1.bounties.reject_submission(
+            bounty_id=args.bounty_id,
+            submission_id=args.submission_id,
+        )
+        emit(result, json_output=config.json_output)
+    except Exception as exc:
+        return handle_error(exc)
+    else:
+        return 0
+    finally:
+        client.close()
+
+
+def handle_submissions_withdraw(args: argparse.Namespace) -> int:
+    """Execute the bounties submissions withdraw command."""
+    bad_id = validate_uuid_id(args.bounty_id, "BOUNTY_ID")
+    if bad_id is not None:
+        return bad_id
+    bad_id = validate_uuid_id(args.submission_id, "SUBMISSION_ID")
+    if bad_id is not None:
+        return bad_id
+    refusal = require_yes(args.yes, "withdraw this submission")
+    if refusal is not None:
+        return refusal
+    config = resolve_config_from_args(args)
+    client = make_client(config)
+    try:
+        result = client.v1.bounties.delete_submission(
+            bounty_id=args.bounty_id,
+            submission_id=args.submission_id,
+        )
+        emit(result, json_output=config.json_output)
+    except Exception as exc:
+        return handle_error(exc)
+    else:
+        return 0
+    finally:
+        client.close()

cli/commands/course_reviews/__init__.py

@@ -0,0 +1,6 @@
+# SPDX-License-Identifier: MIT
+"""Course-reviews command package."""
+
+from .parser import register
+
+__all__ = ["register"]

cli/commands/course_reviews/_download_handler.py

@@ -0,0 +1,104 @@
+# SPDX-License-Identifier: MIT
+"""``course-reviews download`` — fetch the bundle under review.
+
+Fetches the bundle manifest through the typed SDK
+(``client.v1.course_reviews.get_bundle``), then streams each file from
+its presigned URL and reconstructs the bundle's directory tree under
+TARGET so the reviewer can read SKILL.md and references before
+approve/reject.
+
+The manifest call goes through the SDK like every other API call. The
+per-file downloads hit short-lived presigned object-storage URLs
+(carried in the manifest), which have no SDK wrapper — those use httpx
+directly and are allowlisted in ``scripts/check_cli_http.lock``.
+"""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+from typing import Any
+
+import httpx
+
+from cli._config import resolve_config_from_args
+from cli._context import make_client
+from cli._errors import handle_error, print_err, validate_uuid_id
+from cli._output import emit
+
+
+def handle_download(args: argparse.Namespace) -> int:
+    """Execute course-reviews download — fetch bundle for review."""
+    bad_id = validate_uuid_id(args.review_id, "REVIEW_ID")
+    if bad_id is not None:
+        return bad_id
+
+    config = resolve_config_from_args(args)
+    target = Path(
+        args.target if args.target else f"./review-bundles/{args.review_id}"
+    ).resolve()
+    target.mkdir(parents=True, exist_ok=True)
+
+    client = make_client(config)
+    try:
+        bundle = client.v1.course_reviews.get_bundle(review_id=args.review_id)
+    except Exception as exc:
+        return handle_error(exc)
+    finally:
+        client.close()
+
+    files = bundle.files
+    if not files:
+        print_err("Error: review has no assets")
+        return 1
+
+    # Presigned object-storage URLs (download_url) are external and have
+    # no SDK wrapper — stream them directly. See scripts/check_cli_http.lock.
+    try:
+        with httpx.Client(timeout=config.timeout) as http:
+            rc = _download_files(http, files, target)
+            if rc != 0:
+                return rc
+    except Exception as exc:
+        return handle_error(exc)
+
+    _emit_result(bundle, files, target, json_output=config.json_output)
+    return 0
+
+
+def _download_files(http: httpx.Client, files: list[Any], target: Path) -> int:
+    for f in files:
+        filename = f.filename
+        dest = target / filename
+        if not dest.resolve().is_relative_to(target):
+            print_err(f"Error: refusing path escape: {filename}")
+            return 1
+        dest.parent.mkdir(parents=True, exist_ok=True)
+        with http.stream("GET", f.download_url) as r:
+            r.raise_for_status()
+            with open(dest, "wb") as out:
+                for chunk in r.iter_bytes():
+                    out.write(chunk)
+    return 0
+
+
+def _emit_result(
+    bundle: Any, files: list[Any], target: Path, *, json_output: bool
+) -> None:
+    if json_output:
+        emit(
+            {
+                "review_id": bundle.review_id,
+                "target": str(target),
+                "files": [f.filename for f in files],
+            },
+            json_output=True,
+        )
+        return
+    sys.stdout.write(f"Downloaded {len(files)} file(s) to {target}\n")
+    for f in files:
+        sys.stdout.write(f"  {f.filename}\n")
+    sys.stdout.write(
+        "\nNext: read SKILL.md and references/* before approve/reject.\n"
+    )