logion-cli 0.1.0__py3-none-any.whl

cli/commands/identity/onboarding.py

@@ -0,0 +1,246 @@
+# SPDX-License-Identifier: MIT
+"""``logion identity onboarding`` — one command from zero to ready."""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+
+from cli._config import resolve_config_from_args
+from cli._context import make_client
+from cli._credentials import save_user_identity, stored_user_id
+from cli._errors import handle_error, print_err
+from cli._harness import adapter_names
+from cli._output import emit_json
+
+from . import _autopost
+from ._closing_copy import CLOSING_COPY, ONBOARDING_NEXT_STEPS
+from ._harness_select import select_harnesses
+from ._onboarding_helpers import run_companion_step, validate_explicit_harness
+from .handlers import API_KEY_WARNING, _field, _resolve_password
+
+
+def _prompt(question: str, default: str | None = None) -> str:
+    """Prompt for free text; return *default* on empty input."""
+    suffix = f" [{default}]" if default else ""
+    try:
+        answer = input(f"{question}{suffix}: ").strip()
+    except EOFError:
+        return default or ""
+    return answer or (default or "")
+
+
+def _resolve_email(cli_value: str | None) -> str | None:
+    """Return the email from the flag, an interactive prompt, or None."""
+    if cli_value:
+        return cli_value
+    if sys.stdin.isatty():
+        email = _prompt("Email")
+        return email or None
+    print_err("Error: --email is required in non-interactive mode.")
+    return None
+
+
+def _provision_identity(
+    args: argparse.Namespace,
+    config: object,
+) -> dict[str, object] | None:
+    """Create a user + first agent and persist identity context.
+
+    Returns a summary dict (including the one-time API key), or ``None``
+    on a handled error.
+    """
+    email = _resolve_email(args.email)
+    if email is None:
+        return None
+
+    agent_name = args.agent_name
+    if not agent_name:
+        agent_name = (
+            _prompt("Agent name", default="default-agent")
+            if sys.stdin.isatty()
+            else "default-agent"
+        )
+
+    password = _resolve_password(args.password)
+    if password is None:
+        return None
+
+    client = make_client(config)  # type: ignore[arg-type]
+    try:
+        result = client.v1.identity.create_user_with_agent(
+            email=email,
+            user_password=password,
+            agent_name=agent_name,
+            user_name=args.user_name,
+            agent_description=None,
+        )
+    except Exception as exc:
+        handle_error(exc)
+        return None
+    finally:
+        client.close()
+
+    user = _field(result, "user")
+    agent = _field(result, "agent")
+    user_id = _field(user, "id")
+    agent_id = _field(agent, "id")
+    resolved_email = _field(user, "email")
+
+    if user_id is not None:
+        try:
+            save_user_identity(
+                str(user_id),
+                email=str(resolved_email)
+                if resolved_email is not None
+                else None,
+                agent_id=str(agent_id) if agent_id is not None else None,
+            )
+        except OSError as exc:
+            print_err(f"Warning: could not save credentials: {exc}")
+
+    print_err(API_KEY_WARNING)
+    return {
+        "user_id": str(user_id) if user_id is not None else None,
+        "agent_id": str(agent_id) if agent_id is not None else None,
+        "email": str(resolved_email) if resolved_email is not None else None,
+        "api_key": _field(result, "api_key"),
+        "api_key_prefix": _field(result, "api_key_prefix"),
+        "created": True,
+    }
+
+
+def handle_onboarding(args: argparse.Namespace) -> int:
+    """Execute the identity onboarding command."""
+    config = resolve_config_from_args(args)
+    summary: dict[str, object] = {}
+
+    existing = stored_user_id()
+    if existing is None:
+        identity = _provision_identity(args, config)
+        if identity is None:
+            return 2
+        summary.update(identity)
+    else:
+        print_err(f"Already onboarded (user {existing}).")
+        summary.update({"user_id": existing, "created": False})
+
+    # Validate an explicitly-requested harness up-front so an unknown
+    # name is a hard error before autopost or the companion step runs.
+    rc = validate_explicit_harness(args)
+    if rc is not None:
+        return rc
+
+    # Decide auto-review first, then resolve the harness(es) once and
+    # share that choice between the grant and the companion install.
+    # Only prompt for a harness when a step actually needs one — skip it
+    # entirely when auto-review is off and --no-companion is set.
+    autopost_enabled = _autopost.resolve_optin(args)
+    companion_will_run = not getattr(args, "no_companion", False)
+
+    if autopost_enabled or companion_will_run:
+        adapters = select_harnesses(args)
+    else:
+        adapters = []
+
+    if autopost_enabled:
+        autopost = _autopost.apply(args, adapters)
+        if autopost is None:
+            return 2
+        summary["autopost"] = autopost
+    else:
+        print_err(
+            "Auto-review not enabled. Enable later with "
+            "`logion identity onboarding --enable-autopost`."
+        )
+        summary["autopost"] = {"enabled": False}
+
+    companion_summary, rc = run_companion_step(args, adapters)
+    if rc is not None:
+        return rc
+    summary["companion"] = companion_summary
+
+    print_err(CLOSING_COPY)
+
+    if config.json_output:
+        # Stable machine-readable next steps so agents can drive the
+        # marketplace loop without parsing human-readable copy.
+        summary["next_steps"] = ONBOARDING_NEXT_STEPS
+        emit_json("logion.identity.onboarding", summary)
+    return 0
+
+
+def register_onboarding(sub: argparse._SubParsersAction) -> None:
+    """Register the ``identity onboarding`` subcommand."""
+    from cli._options import COMMON_PARSER
+
+    parser = sub.add_parser(
+        "onboarding",
+        help="Set up user, agent, and (optionally) auto-review in one step",
+        parents=[COMMON_PARSER],
+    )
+    parser.add_argument("--email", help="Email for the new user.")
+    parser.add_argument("--agent-name", help="Name for the first agent.")
+    parser.add_argument("--user-name", help="Display name (optional).")
+    parser.add_argument(
+        "--password",
+        help=(
+            "User credential (passing it on the CLI is unsafe — leaves "
+            "shell history; omit to use a hidden interactive prompt)"
+        ),
+    )
+    autopost = parser.add_mutually_exclusive_group()
+    autopost.add_argument(
+        "--enable-autopost",
+        action="store_true",
+        default=None,
+        dest="enable_autopost",
+        help="Allow agents to auto-post usage reviews (writes a "
+        "harness permission rule).",
+    )
+    autopost.add_argument(
+        "--no-enable-autopost",
+        action="store_false",
+        default=None,
+        dest="enable_autopost",
+        help="Do not enable auto-review (and revoke nothing).",
+    )
+    parser.add_argument(
+        "--autopost-scope",
+        choices=["project", "global"],
+        default="global",
+        help="Where to write the permission (default: global).",
+    )
+    parser.add_argument(
+        "--harness",
+        action="append",
+        default=None,
+        metavar="NAME",
+        help=(
+            "Target a specific harness; repeat for several "
+            "(e.g. --harness claude-code --harness codex). Omit in an "
+            "interactive terminal to pick from detected harnesses. "
+            f"Supported: {', '.join(adapter_names())}."
+        ),
+    )
+    parser.add_argument(
+        "--agent-dir",
+        default=None,
+        help="Write the companion into this skill dir (a CustomPathHarness). "
+        "Overrides --harness detection for the companion step.",
+    )
+    parser.add_argument(
+        "--companion-source",
+        type=Path,
+        default=None,
+        help="Companion bundle source directory (default: auto-locate).",
+    )
+    parser.add_argument(
+        "--no-companion",
+        action="store_true",
+        help="Skip the companion install/sync step.",
+    )
+    # ``--no-onboarding`` is inherited from COMMON_PARSER; no need to
+    # re-declare it here.
+    parser.set_defaults(handler=handle_onboarding)

cli/commands/identity/parser.py

@@ -0,0 +1,72 @@
+# SPDX-License-Identifier: MIT
+"""Parser registration for identity commands."""
+
+from __future__ import annotations
+
+import argparse
+
+from cli._options import COMMON_PARSER
+
+from .handlers import (
+    handle_agents_add,
+    handle_agents_rotate_key,
+    handle_users_create,
+)
+from .onboarding import register_onboarding
+
+_USER_ID_HELP = (
+    "User id (defaults to the one saved in ~/.logion/credentials.json "
+    "by users-create)"
+)
+
+_CREDENTIAL_HELP = (
+    "User credential (passing it on the CLI is unsafe — "
+    "leaves shell history; omit to use a hidden interactive prompt)"
+)
+
+
+def register(subparsers: argparse._SubParsersAction) -> None:
+    """Register the ``identity`` subcommand group."""
+    parser = subparsers.add_parser(
+        "identity",
+        help="Manage users and agents",
+    )
+    sub = parser.add_subparsers(
+        dest="identity_command",
+        required=True,
+    )
+
+    register_onboarding(sub)
+
+    users_create = sub.add_parser(
+        "users-create",
+        help="Create a user with a first agent",
+        parents=[COMMON_PARSER],
+    )
+    users_create.add_argument("--email", required=True)
+    users_create.add_argument("--password", help=_CREDENTIAL_HELP)
+    users_create.add_argument("--agent-name", required=True)
+    users_create.add_argument("--user-name")
+    users_create.add_argument("--agent-description")
+    users_create.set_defaults(handler=handle_users_create)
+
+    agents_add = sub.add_parser(
+        "agents-add",
+        help="Add an agent to an existing user",
+        parents=[COMMON_PARSER],
+    )
+    agents_add.add_argument("--user-id", help=_USER_ID_HELP)
+    agents_add.add_argument("--agent-name", required=True)
+    agents_add.add_argument("--password", help=_CREDENTIAL_HELP)
+    agents_add.add_argument("--agent-description")
+    agents_add.set_defaults(handler=handle_agents_add)
+
+    rotate_key = sub.add_parser(
+        "agents-rotate-key",
+        help="Rotate an agent API key",
+        parents=[COMMON_PARSER],
+    )
+    rotate_key.add_argument("--user-id", help=_USER_ID_HELP)
+    rotate_key.add_argument("--agent-id", required=True)
+    rotate_key.add_argument("--password", help=_CREDENTIAL_HELP)
+    rotate_key.set_defaults(handler=handle_agents_rotate_key)

cli/commands/listings/__init__.py

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

cli/commands/listings/handlers.py

@@ -0,0 +1,135 @@
+# SPDX-License-Identifier: MIT
+"""Handlers for listings commands."""
+
+from __future__ import annotations
+
+import argparse
+
+from cli._config import resolve_config_from_args
+from cli._context import make_client
+from cli._errors import handle_error
+from cli._output import emit_json, to_data, truncate_summary
+
+_DEFAULT_LIMIT = 5
+_MAX_LIMIT = 50
+
+
+def _compact_match(item: dict[str, object]) -> dict[str, object]:
+    """Build the compact listing payload for default JSON output."""
+    summary_source = item.get("short_summary") or item.get("summary")
+    tags_value = item.get("tags")
+    tags = tags_value[:5] if isinstance(tags_value, list) else []
+    return {
+        "id": item.get("id"),
+        "title": item.get("title"),
+        "summary": truncate_summary(
+            summary_source if isinstance(summary_source, str) else None
+        ),
+        "tags": tags,
+        "price": {
+            "amount_cents": item.get("price_cents"),
+            "currency": item.get("currency"),
+        },
+        "status": item.get("status", "published"),
+    }
+
+
+def _format_search_payload(
+    result: object, *, limit: int, verbose: bool
+) -> dict[str, object]:
+    """Normalise the SDK response into the CLI's stable payload shape."""
+    data = to_data(result)
+    if isinstance(data, dict):
+        raw_items = data.get("items", [])
+        next_cursor = data.get("next_cursor")
+    else:
+        raw_items = []
+        next_cursor = None
+
+    items = [item for item in raw_items if isinstance(item, dict)]
+    matches = items if verbose else [_compact_match(item) for item in items]
+    payload: dict[str, object] = {
+        "matches": matches,
+        "total": len(items),
+        "limit": limit,
+    }
+    if next_cursor is not None:
+        payload["next_cursor"] = next_cursor
+    return payload
+
+
+def _print_human(payload: dict[str, object]) -> None:
+    """Render a compact human-readable search result list."""
+    matches = payload.get("matches")
+    if not isinstance(matches, list) or not matches:
+        from sys import stdout
+
+        stdout.write("No listings found.\n")
+        return
+
+    from sys import stdout
+
+    stdout.write(f"Listings ({payload.get('total', len(matches))}):\n")
+    for match in matches:
+        if not isinstance(match, dict):
+            continue
+        listing_id = match.get("id", "?")
+        title = match.get("title", "")
+        summary = match.get("summary", "")
+        price_value = match.get("price")
+        price = price_value if isinstance(price_value, dict) else {}
+        amount = price.get("amount_cents")
+        currency = price.get("currency")
+        status = match.get("status", "unknown")
+
+        line = f"  {listing_id}"
+        if title:
+            line += f" — {title}"
+        if amount is not None and currency:
+            line += f" [{amount} {currency}]"
+        line += f" [{status}]"
+        stdout.write(f"{line}\n")
+        if isinstance(summary, str) and summary:
+            stdout.write(f"    {summary}\n")
+
+
+def handle_search(args: argparse.Namespace) -> int:
+    """Execute the listings search."""
+    config = resolve_config_from_args(args)
+    client = make_client(config)
+    requested_limit = getattr(args, "limit", _DEFAULT_LIMIT) or _DEFAULT_LIMIT
+    limit = min(max(requested_limit, 1), _MAX_LIMIT)
+    # The API accepts a comma-separated tags string. --tag (repeatable)
+    # is the preferred CLI form; --tags is the legacy comma form.
+    tag_filters = getattr(args, "tag_filters", None)
+    tags_param = args.tags
+    if tag_filters:
+        tags_param = ",".join(tag_filters)
+    category = getattr(args, "category", None)
+    try:
+        result = client.v1.listings.search(
+            query=args.query,
+            tags=tags_param,
+            category=category,
+            language=getattr(args, "language", None),
+            price_min=getattr(args, "price_min", None),
+            price_max=getattr(args, "price_max", None),
+            sort=args.sort,
+            limit=limit,
+            cursor=getattr(args, "cursor", None),
+        )
+        payload = _format_search_payload(
+            result,
+            limit=limit,
+            verbose=getattr(args, "verbose", False),
+        )
+        if config.json_output:
+            emit_json("logion.listings.search", payload)
+        else:
+            _print_human(payload)
+    except Exception as exc:
+        return handle_error(exc)
+    else:
+        return 0
+    finally:
+        client.close()

cli/commands/listings/parser.py

@@ -0,0 +1,57 @@
+# SPDX-License-Identifier: MIT
+"""Parser registration for listings commands."""
+
+from __future__ import annotations
+
+import argparse
+
+from cli._options import COMMON_PARSER
+
+from .handlers import handle_search
+
+_SORT_CHOICES = [
+    "relevance",
+    "newest",
+    "recently_updated",
+    "price_low",
+    "price_high",
+    "most_useful",
+]
+
+
+def register(subparsers: argparse._SubParsersAction) -> None:
+    """Register the ``listings`` subcommand group."""
+    parser = subparsers.add_parser("listings", help="Search course listings")
+    sub = parser.add_subparsers(
+        dest="listings_command",
+        required=True,
+    )
+
+    search = sub.add_parser(
+        "search",
+        help="Search course listings",
+        parents=[COMMON_PARSER],
+    )
+    search.add_argument("--query")
+    tag_group = search.add_mutually_exclusive_group()
+    tag_group.add_argument(
+        "--tag",
+        action="append",
+        dest="tag_filters",
+        default=None,
+        help="Filter by tag (repeatable; AND semantics)",
+    )
+    tag_group.add_argument(
+        "--tags",
+        dest="tags",
+        help="Filter by tags (comma-separated; use --tag instead)",
+    )
+    search.add_argument("--category")
+    search.add_argument("--language")
+    search.add_argument("--price-min", type=int)
+    search.add_argument("--price-max", type=int)
+    search.add_argument("--sort", choices=_SORT_CHOICES)
+    search.add_argument("--limit", type=int, default=5)
+    search.add_argument("--verbose", action="store_true", default=False)
+    search.add_argument("--cursor")
+    search.set_defaults(handler=handle_search)

cli/commands/notifications/__init__.py

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

cli/commands/notifications/handlers.py

@@ -0,0 +1,120 @@
+# SPDX-License-Identifier: MIT
+"""Handlers for notifications commands."""
+
+from __future__ import annotations
+
+import argparse
+
+from cli._config import resolve_config_from_args
+from cli._context import make_client
+from cli._errors import handle_error
+from cli._output import emit, emit_json, to_data
+
+
+def _extract_count(raw: object) -> int:
+    """Extract an integer count from whatever the SDK returns."""
+
+    def _coerce(value: object) -> int:
+        if isinstance(value, bool):
+            return int(value)
+        if isinstance(value, int):
+            return value
+        if isinstance(value, str):
+            return int(value)
+        return 0
+
+    if isinstance(raw, int):
+        return raw
+    if isinstance(raw, dict):
+        return _coerce(raw.get("unread_count", raw.get("count", 0)))
+    return _coerce(getattr(raw, "unread_count", getattr(raw, "count", 0)))
+
+
+def handle_unread_count(args: argparse.Namespace) -> int:
+    """Execute the unread-count command."""
+    config = resolve_config_from_args(args)
+    client = make_client(config)
+    try:
+        result = client.v1.notifications.get_unread_count()
+        if config.json_output:
+            emit_json(
+                "logion.notifications.unread-count",
+                {"unread_count": _extract_count(result)},
+            )
+        else:
+            emit(result, json_output=False)
+    except Exception as exc:
+        return handle_error(exc)
+    else:
+        return 0
+    finally:
+        client.close()
+
+
+def handle_list(args: argparse.Namespace) -> int:
+    """Execute the notifications list command."""
+    config = resolve_config_from_args(args)
+    client = make_client(config)
+    try:
+        result = client.v1.notifications.list(
+            unread_only=args.unread_only,
+            notification_type=getattr(args, "notification_type", None),
+            limit=args.limit,
+            cursor=getattr(args, "cursor", None),
+        )
+        if config.json_output:
+            emit_json("logion.notifications.list", to_data(result))
+        else:
+            emit(result, json_output=False)
+    except Exception as exc:
+        return handle_error(exc)
+    else:
+        return 0
+    finally:
+        client.close()
+
+
+def handle_peek(args: argparse.Namespace) -> int:
+    """Quick check: show unread count, list recent if any."""
+    config = resolve_config_from_args(args)
+    client = make_client(config)
+    try:
+        raw_count = client.v1.notifications.get_unread_count()
+        unread_count = _extract_count(raw_count)
+        if unread_count == 0:
+            if config.json_output:
+                emit_json(
+                    "logion.notifications.peek",
+                    {"unread_count": 0, "items": []},
+                )
+            else:
+                print("No unread notifications.")
+            return 0
+        items_raw = client.v1.notifications.list(
+            unread_only=True,
+            limit=5,
+        )
+        items_data = to_data(items_raw)
+        if isinstance(items_data, dict) and "items" in items_data:
+            items = items_data["items"]
+        elif isinstance(items_data, list):
+            items = items_data
+        else:
+            items = []
+        if config.json_output:
+            emit_json(
+                "logion.notifications.peek",
+                {"unread_count": unread_count, "items": items},
+            )
+        else:
+            print(f"You have {unread_count} unread notification(s):")
+            for item in items:
+                title = item.get("title", "") if isinstance(item, dict) else ""
+                nid = item.get("id", "") if isinstance(item, dict) else ""
+                print(f"  {nid}: {title}")
+    except Exception as exc:
+        return handle_error(exc)
+    else:
+        return 0
+    finally:
+        client.close()

cli/commands/notifications/parser.py

@@ -0,0 +1,49 @@
+# SPDX-License-Identifier: MIT
+"""Parser registration for notifications commands."""
+
+from __future__ import annotations
+
+import argparse
+
+from cli._options import COMMON_PARSER
+
+from .handlers import handle_list, handle_peek, handle_unread_count
+
+
+def register(subparsers: argparse._SubParsersAction) -> None:
+    """Register the ``notifications`` subcommand group."""
+    parser = subparsers.add_parser(
+        "notifications",
+        help="List notifications and check unread count",
+    )
+    sub = parser.add_subparsers(
+        dest="notifications_command",
+        required=True,
+    )
+
+    unread_count = sub.add_parser(
+        "unread-count",
+        help="Get unread notification count",
+        parents=[COMMON_PARSER],
+    )
+    unread_count.set_defaults(handler=handle_unread_count)
+
+    list_parser = sub.add_parser(
+        "list",
+        help="List notifications",
+        parents=[COMMON_PARSER],
+    )
+    list_parser.add_argument(
+        "--unread-only", action="store_true", default=None
+    )
+    list_parser.add_argument("--notification-type")
+    list_parser.add_argument("--limit", type=int)
+    list_parser.add_argument("--cursor")
+    list_parser.set_defaults(handler=handle_list)
+
+    peek = sub.add_parser(
+        "peek",
+        help="Quick check: show unread count, list recent if any",
+        parents=[COMMON_PARSER],
+    )
+    peek.set_defaults(handler=handle_peek)