reviso-cli 0.1.0__tar.gz

reviso_cli-0.1.0/LICENSE

@@ -0,0 +1,25 @@
+MIT License
+
+Copyright (c) 2026 Reviso
+
+This license applies to the contents of this repository: the Reviso command line
+client. It does not apply to the Reviso product, its service, or its server
+software, none of which are open source and none of which are licensed here.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

reviso_cli-0.1.0/PKG-INFO

@@ -0,0 +1,146 @@
+Metadata-Version: 2.4
+Name: reviso-cli
+Version: 0.1.0
+Summary: Command line client for Reviso: publish drafts for human review, read reviewer comments back, and publish revisions safely.
+License: MIT License
+        
+        Copyright (c) 2026 Reviso
+        
+        This license applies to the contents of this repository: the Reviso command line
+        client. It does not apply to the Reviso product, its service, or its server
+        software, none of which are open source and none of which are licensed here.
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Keywords: reviso,review,collaboration,documents,cli,agent
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Text Processing :: Markup
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: test
+Requires-Dist: pytest>=8.0; extra == "test"
+Dynamic: license-file
+
+# reviso-cli
+
+Command line client for [Reviso](https://reviso.work), a content collaboration
+system where agents publish Markdown and HTML drafts and a human team reviews
+them.
+
+This is the client half of Reviso. It talks to a Reviso server over HTTP and
+contains no server code. It has **no runtime dependencies**: the transport is
+`urllib`, so publishing a Markdown file does not pull a dependency graph into an
+agent's environment.
+
+## Install
+
+Not on PyPI yet, so install from source:
+
+```bash
+pip install git+https://github.com/reviso-si/reviso-cli
+# or run it without installing
+uvx --from git+https://github.com/reviso-si/reviso-cli reviso --help
+```
+
+Installs the `reviso` command. Once the package is published this becomes
+`pip install reviso-cli`.
+
+## Quick start
+
+```bash
+reviso auth login --server https://reviso.work
+# set REVISO_AUTOMATION_KEY in the environment first, or pass --key
+reviso doctor --json
+
+reviso publish draft.md --title "Q3 launch plan" --description "Initial draft"
+# prints the document URL
+
+reviso documents --json                 # find the document id
+reviso packet doc_abc123 --format json  # reviewer comments and version metadata
+reviso versions doc_abc123              # read the current version id
+
+reviso update doc_abc123 revised.md \
+  --description "Address reviewer feedback" \
+  --base-version-id ver_xyz
+```
+
+## The rule that matters
+
+**Always pass `--base-version-id` when you revise a document.**
+
+Omitting it is not a safe default. Without it the command re-bases onto whatever
+version is newest and lets your write win, which silently discards a human's
+concurrent edit. The safe shape is always two steps:
+
+```bash
+reviso versions <document_id>        # take the newest version_id
+reviso update <document_id> file --description "..." --base-version-id <ver_...>
+```
+
+If the write is rejected as a conflict, re-read and re-apply your change on top of
+the human's edit. Do not retry with the flag removed.
+
+## Command groups
+
+| Group | Commands |
+| --- | --- |
+| Connection | `auth`, `doctor`, `health`, `ready`, `version` |
+| Documents | `publish`, `open`, `status`, `documents`, `search`, `packet` |
+| Revisions | `versions`, `diff`, `update`, `rollback` |
+| Reviewers | `invite`, `guest`, `comment`, `reply`, `resolve` |
+| Data | `export`, `import`, `workspaces` |
+
+## Deliberately not in this client
+
+These are boundaries, not gaps to be filled later:
+
+- **No server commands.** Starting a Reviso server is not part of the client.
+- **No share-link creation.** A share link carries a bearer token in its URL, and
+  creating one is a browser action where the person handing it out can see who it
+  is going to. Invites by email are here instead.
+- **No owner or operator surfaces.** Metrics, debug replay, and internal replay
+  endpoints are not exposed.
+
+If you need MCP tools rather than a shell, the hosted connector is the better
+path in most hosts. See [reviso-agent](https://github.com/reviso-si/reviso-agent)
+for the agent skill.
+
+## Known limitations
+
+- `publish` prints only the document URL. It does not return the document id, so
+  use `reviso documents --json` to continue from the id.
+- `update` and `rollback` accept an omitted base version and fall back to
+  last-writer-wins. Always pass the flag. A future release should make the safe
+  behaviour the default.
+
+## License
+
+MIT. See [LICENSE](LICENSE).
+
+The Reviso product itself is **not** open source. This repository covers the
+client only; it grants no rights to the service or its server software. See
+[VISIBILITY.md](VISIBILITY.md) for the boundary this repository holds, and
+[CONTRIBUTING.md](CONTRIBUTING.md) before opening a pull request.

reviso_cli-0.1.0/README.md

@@ -0,0 +1,100 @@
+# reviso-cli
+
+Command line client for [Reviso](https://reviso.work), a content collaboration
+system where agents publish Markdown and HTML drafts and a human team reviews
+them.
+
+This is the client half of Reviso. It talks to a Reviso server over HTTP and
+contains no server code. It has **no runtime dependencies**: the transport is
+`urllib`, so publishing a Markdown file does not pull a dependency graph into an
+agent's environment.
+
+## Install
+
+Not on PyPI yet, so install from source:
+
+```bash
+pip install git+https://github.com/reviso-si/reviso-cli
+# or run it without installing
+uvx --from git+https://github.com/reviso-si/reviso-cli reviso --help
+```
+
+Installs the `reviso` command. Once the package is published this becomes
+`pip install reviso-cli`.
+
+## Quick start
+
+```bash
+reviso auth login --server https://reviso.work
+# set REVISO_AUTOMATION_KEY in the environment first, or pass --key
+reviso doctor --json
+
+reviso publish draft.md --title "Q3 launch plan" --description "Initial draft"
+# prints the document URL
+
+reviso documents --json                 # find the document id
+reviso packet doc_abc123 --format json  # reviewer comments and version metadata
+reviso versions doc_abc123              # read the current version id
+
+reviso update doc_abc123 revised.md \
+  --description "Address reviewer feedback" \
+  --base-version-id ver_xyz
+```
+
+## The rule that matters
+
+**Always pass `--base-version-id` when you revise a document.**
+
+Omitting it is not a safe default. Without it the command re-bases onto whatever
+version is newest and lets your write win, which silently discards a human's
+concurrent edit. The safe shape is always two steps:
+
+```bash
+reviso versions <document_id>        # take the newest version_id
+reviso update <document_id> file --description "..." --base-version-id <ver_...>
+```
+
+If the write is rejected as a conflict, re-read and re-apply your change on top of
+the human's edit. Do not retry with the flag removed.
+
+## Command groups
+
+| Group | Commands |
+| --- | --- |
+| Connection | `auth`, `doctor`, `health`, `ready`, `version` |
+| Documents | `publish`, `open`, `status`, `documents`, `search`, `packet` |
+| Revisions | `versions`, `diff`, `update`, `rollback` |
+| Reviewers | `invite`, `guest`, `comment`, `reply`, `resolve` |
+| Data | `export`, `import`, `workspaces` |
+
+## Deliberately not in this client
+
+These are boundaries, not gaps to be filled later:
+
+- **No server commands.** Starting a Reviso server is not part of the client.
+- **No share-link creation.** A share link carries a bearer token in its URL, and
+  creating one is a browser action where the person handing it out can see who it
+  is going to. Invites by email are here instead.
+- **No owner or operator surfaces.** Metrics, debug replay, and internal replay
+  endpoints are not exposed.
+
+If you need MCP tools rather than a shell, the hosted connector is the better
+path in most hosts. See [reviso-agent](https://github.com/reviso-si/reviso-agent)
+for the agent skill.
+
+## Known limitations
+
+- `publish` prints only the document URL. It does not return the document id, so
+  use `reviso documents --json` to continue from the id.
+- `update` and `rollback` accept an omitted base version and fall back to
+  last-writer-wins. Always pass the flag. A future release should make the safe
+  behaviour the default.
+
+## License
+
+MIT. See [LICENSE](LICENSE).
+
+The Reviso product itself is **not** open source. This repository covers the
+client only; it grants no rights to the service or its server software. See
+[VISIBILITY.md](VISIBILITY.md) for the boundary this repository holds, and
+[CONTRIBUTING.md](CONTRIBUTING.md) before opening a pull request.

reviso_cli-0.1.0/pyproject.toml

@@ -0,0 +1,39 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "reviso-cli"
+version = "0.1.0"
+description = "Command line client for Reviso: publish drafts for human review, read reviewer comments back, and publish revisions safely."
+readme = "README.md"
+requires-python = ">=3.11"
+license = { file = "LICENSE" }
+keywords = ["reviso", "review", "collaboration", "documents", "cli", "agent"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Environment :: Console",
+  "Intended Audience :: Developers",
+  "License :: OSI Approved :: MIT License",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Topic :: Text Processing :: Markup",
+]
+
+# The client is stdlib-only on purpose. Installing it must not pull a dependency
+# graph into an agent's environment to publish a Markdown file.
+dependencies = []
+
+[project.optional-dependencies]
+test = ["pytest>=8.0"]
+
+[project.scripts]
+reviso = "reviso_cli.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["src"]

reviso_cli-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

reviso_cli-0.1.0/src/reviso_cli/__init__.py

@@ -0,0 +1,8 @@
+"""Reviso command line client."""
+from __future__ import annotations
+
+from .client import RevisoClient
+
+__version__ = "0.1.0"
+
+__all__ = ["RevisoClient", "__version__"]

reviso_cli-0.1.0/src/reviso_cli/__main__.py

@@ -0,0 +1,6 @@
+from __future__ import annotations
+
+from .cli import main
+
+if __name__ == "__main__":
+    main()

reviso_cli-0.1.0/src/reviso_cli/access.py

@@ -0,0 +1,49 @@
+"""Access levels used by invites and share links.
+
+The three levels below are the vocabulary a user types and sees. What each level
+resolves to on the server is deliberately not represented here: the server owns
+that mapping, and the client sends the level, not an expanded result.
+"""
+from __future__ import annotations
+
+ACCESS_TO_ROLE = {
+    "view": "viewer",
+    "comment": "commenter",
+    "edit": "editor",
+}
+
+VALID_ACCESS = tuple(ACCESS_TO_ROLE)
+
+
+def normalize_access(access: str) -> str:
+    value = str(access or "comment").strip()
+    if value not in ACCESS_TO_ROLE:
+        raise ValueError("access must be view, comment, or edit")
+    return value
+
+
+def role_for_access(access: str) -> str:
+    return ACCESS_TO_ROLE[normalize_access(access)]
+
+
+def access_from_body(body: dict) -> str:
+    if str(body.get("role", "")).strip():
+        raise ValueError("role is no longer accepted; pass access")
+    return normalize_access(str(body.get("access") or "comment"))
+
+
+def invite_access_from_body(body: dict) -> str:
+    return access_from_body(body)
+
+
+def invite_for_public(item: dict) -> dict:
+    result = {key: value for key, value in item.items() if key != "role"}
+    result["access"] = normalize_access(str(item.get("access") or "comment"))
+    return result
+
+
+def invite_list_for_public(result: dict) -> dict:
+    return {
+        **result,
+        "invites": [invite_for_public(item) for item in result.get("invites", [])],
+    }

reviso_cli-0.1.0/src/reviso_cli/cli/__init__.py

@@ -0,0 +1,276 @@
+"""Command line dispatcher. Every server call goes through RevisoClient."""
+from __future__ import annotations
+
+import argparse
+import json
+import os
+from pathlib import Path
+
+from .. import command_journal
+from ..client import RevisoClient
+from ..document_route_keys import public_document_path
+from ..document_search import search_documents
+from ..errors import ValidationError
+from ..local import read_mapping, write_mapping  # noqa: F401
+from ..origin import DEFAULT_SERVER_URL
+from ..paths import config_path, packet_path, read_json, write_json
+from ..scope import resolve_agent_create_scope
+from .doctor import doctor_report, print_doctor
+from .guest_comments import add_guest_comment_commands
+from .invites import add_invite_commands
+from .versions import add_version_commands, format_file_arg
+
+# Response blocks that are browser UI state. The human status line drops them;
+# --json keeps them.
+ACCESS_KEYS = ("effective_access", "security_policy")
+
+
+def _load_config() -> dict:
+    path = config_path()
+    if path.exists():
+        return read_json(path)
+    return {}
+
+
+def _server_url() -> str:
+    cfg = _load_config()
+    return os.environ.get("REVISO_SERVER",
+                          cfg.get("server", DEFAULT_SERVER_URL))
+
+
+def _automation_key(cfg: dict) -> str:
+    return (os.environ.get("REVISO_AUTOMATION_KEY")
+            or cfg.get("automation_key", ""))
+
+
+def _client() -> RevisoClient:
+    return RevisoClient(_server_url(), _automation_key(_load_config()) or None)
+
+
+def cmd_auth(args: argparse.Namespace) -> None:
+    if args.action == "login":
+        key = args.key or os.environ.get("REVISO_AUTOMATION_KEY", "")
+        server = args.server or os.environ.get("REVISO_SERVER",
+                                               DEFAULT_SERVER_URL)
+        if not key:
+            print("No automation key. Create one in Reviso under Settings -> "
+                  "Integrations, then set REVISO_AUTOMATION_KEY or pass --key.")
+            return
+        write_json(config_path(), {"server": server, "automation_key": key})
+        print(f"Saved to {config_path()}")
+    elif args.action == "status":
+        cfg = _load_config()
+        print(f"server: {cfg.get('server', '(not set)')}")
+        print(f"key: {'set' if cfg.get('automation_key') else '(not set)'}")
+        print(f"config: {config_path()}")
+    else:
+        print(f"unknown auth action: {args.action}")
+
+
+def cmd_publish(args: argparse.Namespace) -> None:
+    path = Path(args.file)
+    scope = _workspace_scope(args.workspace_id or "", args.parent_id or "")
+    content = path.read_text()
+    fmt = format_file_arg(args, path)
+    title = args.title or path.name
+    # A journaled operation_id is reused across reruns of THIS command, so a
+    # crashed-then-rerun publish replays instead of double-creating. Cleared
+    # only after every local success step has completed.
+    parts = [title, content, fmt, args.description or "",
+             scope.workspace_id, scope.parent_id]
+    op = command_journal.operation_id_for("publish", parts)
+    result = _client().publish(title, content, fmt, args.description,
+                               scope.workspace_id, scope.parent_id,
+                               operation_id=op)
+    mapping = write_mapping(result, path)
+    print(mapping["url"])
+    command_journal.forget("publish", parts)
+
+
+def cmd_open(args: argparse.Namespace) -> None:
+    print(f"{_server_url()}{public_document_path(args.document_id)}")
+
+
+def cmd_status(args: argparse.Namespace) -> None:
+    payload = _client().status(args.document_id)
+    if args.json:
+        print(json.dumps(payload, indent=2, sort_keys=True))
+        return
+    for key, value in payload.items():
+        if key in ACCESS_KEYS:
+            continue
+        print(f"{key}: {value}")
+
+
+def cmd_server_info(args: argparse.Namespace) -> None:
+    client = _client()
+    payload = {"health": client.health,
+               "ready": client.ready,
+               "version": client.version_info}[args.kind]()
+    print(json.dumps(payload, indent=2, sort_keys=True))
+
+
+def cmd_workspaces(args: argparse.Namespace) -> None:
+    payload = _client().workspaces()
+    if args.json:
+        print(json.dumps(payload, indent=2, sort_keys=True))
+        return
+    for ws in payload.get("workspaces", []):
+        print(f"{ws.get('workspace_id')}\t{ws.get('workspace_name')}\t"
+              f"[{ws.get('workspace_type')}]\t{ws.get('role')}")
+
+
+def cmd_documents(args: argparse.Namespace) -> None:
+    payload = _client().dashboard(args.workspace_id or "")
+    if args.json:
+        print(json.dumps(payload, indent=2, sort_keys=True))
+        return
+    for doc in payload.get("reviews", []):
+        status = doc.get("lifecycle_status") or ""
+        print(f"{doc.get('document_id')}\t{doc.get('title')}\t"
+              f"[{status}]\t{doc.get('unresolved_count')} open")
+
+
+def cmd_search(args: argparse.Namespace) -> None:
+    try:
+        payload = search_documents(
+            _client(), args.query, workspace_id=args.workspace_id or "",
+            limit=args.limit, archived=args.archived,
+            include_content=args.include_content)
+    except ValidationError as exc:
+        raise SystemExit(str(exc)) from exc
+    if args.json:
+        print(json.dumps(payload, indent=2, sort_keys=True))
+        return
+    for doc in payload.get("matches", []):
+        print(f"{doc.get('document_id')}\t{doc.get('title')}\t"
+              f"[{doc.get('match_field')}]\t{doc.get('snippet')}")
+
+
+def cmd_doctor(args: argparse.Namespace) -> None:
+    cfg = _load_config()
+    report = doctor_report(
+        _client(), _server_url(), _automation_key(cfg),
+        os.environ.get("REVISO_WORKSPACE_ID", cfg.get("workspace_id", "")))
+    if args.json:
+        print(json.dumps(report, indent=2, sort_keys=True))
+        return
+    print_doctor(report)
+
+
+def cmd_packet(args: argparse.Namespace) -> None:
+    v = "2" if args.v2 else "3"
+    packet = _client().packet(args.document_id, args.thread_id, version=v)
+    pid = packet.get("document_id", args.document_id)
+    path = packet_path(f"pkt_{pid}", "json")
+    write_json(path, packet)
+    print(str(path))
+
+
+def _workspace_scope(explicit: str = "", parent_id: str = ""):
+    cfg = _load_config()
+    key = _automation_key(cfg)
+    return resolve_agent_create_scope(
+        explicit_workspace_id=explicit, explicit_parent_id=parent_id,
+        config=cfg, has_automation_key=key.startswith("rak_"))
+
+
+def _add_basic(sub: argparse._SubParsersAction) -> None:
+    auth = sub.add_parser("auth")
+    auth.add_argument("action", nargs="?", default="login")
+    auth.add_argument("--server")
+    auth.add_argument("--key")
+    auth.set_defaults(func=cmd_auth)
+    pub = sub.add_parser("publish")
+    pub.add_argument("file")
+    pub.add_argument("--title")
+    pub.add_argument("--format", choices=["markdown", "md", "html"])
+    pub.add_argument("--description", default="Initial draft")
+    pub.add_argument("--workspace-id", default="")
+    pub.add_argument("--parent-id", default="")
+    pub.set_defaults(func=cmd_publish)
+    opn = sub.add_parser("open")
+    opn.add_argument("document_id")
+    opn.set_defaults(func=cmd_open)
+    st = sub.add_parser("status")
+    st.add_argument("document_id")
+    st.add_argument("--json", action="store_true")
+    st.set_defaults(func=cmd_status)
+    wss = sub.add_parser("workspaces")
+    wss.add_argument("--json", action="store_true")
+    wss.set_defaults(func=cmd_workspaces)
+    docs = sub.add_parser("documents")
+    docs.add_argument("--workspace-id", default="")
+    docs.add_argument("--json", action="store_true")
+    docs.set_defaults(func=cmd_documents)
+    search = sub.add_parser("search")
+    search.add_argument("query")
+    search.add_argument("--workspace-id", default="")
+    search.add_argument("--limit", type=int, default=10)
+    search.add_argument("--archived", action="store_true")
+    search.add_argument("--include-content", action="store_true")
+    search.add_argument("--json", action="store_true")
+    search.set_defaults(func=cmd_search)
+    doctor = sub.add_parser("doctor")
+    doctor.add_argument("--json", action="store_true")
+    doctor.set_defaults(func=cmd_doctor)
+    for name in ("health", "ready", "version"):
+        srv = sub.add_parser(name)
+        srv.set_defaults(func=cmd_server_info, kind=name)
+
+
+def _add_packet(sub: argparse._SubParsersAction) -> None:
+    pkt = sub.add_parser("packet")
+    pkt.add_argument("document_id")
+    pkt.add_argument("--format", choices=["json"], default="json")
+    pkt.add_argument("--thread-id", action="append")
+    pkt.add_argument("--v2", action="store_true",
+                     help="Use legacy packet v2 with sections")
+    pkt.set_defaults(func=cmd_packet)
+
+
+def _add_review_io(sub: argparse._SubParsersAction) -> None:
+    exp = sub.add_parser("export")
+    exp.add_argument("document_id")
+    exp.add_argument("--output", default="")
+    exp.set_defaults(func=cmd_export)
+    imp = sub.add_parser("import")
+    imp.add_argument("file")
+    imp.add_argument("--workspace-id", default="")
+    imp.add_argument("--parent-id", default="")
+    imp.set_defaults(func=cmd_import)
+
+
+def cmd_export(args: argparse.Namespace) -> None:
+    bundle = _client().export_review(args.document_id)
+    if args.output:
+        write_json(Path(args.output), bundle)
+        print(args.output)
+        return
+    print(json.dumps(bundle, indent=2, sort_keys=True))
+
+
+def cmd_import(args: argparse.Namespace) -> None:
+    bundle = read_json(Path(args.file))
+    scope = _workspace_scope(args.workspace_id or "", args.parent_id or "")
+    result = _client().import_review(
+        bundle, scope.workspace_id, scope.parent_id)
+    print(json.dumps(result, indent=2, sort_keys=True))
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="reviso")
+    sub = parser.add_subparsers(dest="cmd", required=True)
+    _add_basic(sub)
+    _add_packet(sub)
+    _add_review_io(sub)
+    add_guest_comment_commands(sub, _client)
+    add_invite_commands(sub, _client)
+    add_version_commands(sub, _client)
+    return parser
+
+
+def main(argv: list[str] | None = None) -> None:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    args.func(args)