autoverse 0.1.0__tar.gz

autoverse-0.1.0/MANIFEST.in

@@ -0,0 +1,12 @@
+include README.md
+include pyproject.toml
+graft src/autoverse
+graft tests
+global-exclude *.py[cod] *.so .DS_Store
+prune .venv
+prune venv
+prune deploy
+prune doc
+prune .pytest_cache
+prune src/autoverse.egg-info
+recursive-exclude src *.egg-info

autoverse-0.1.0/PKG-INFO

@@ -0,0 +1,41 @@
+Metadata-Version: 2.4
+Name: autoverse
+Version: 0.1.0
+Summary: Command-line client for Autoverse literature search
+Project-URL: Homepage, https://app.autoverse.nz
+Project-URL: Documentation, https://app.autoverse.nz/#/docs/cli
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: httpx<1,>=0.27
+Requires-Dist: keyring<26,>=25
+Requires-Dist: mcp<3,>=2
+Requires-Dist: pydantic<3,>=2.10
+Requires-Dist: typer<1,>=0.27
+Requires-Dist: uvicorn[standard]<1,>=0.32
+Provides-Extra: test
+Requires-Dist: pytest<9,>=8.3; extra == "test"
+Requires-Dist: pytest-asyncio<1,>=0.25; extra == "test"
+
+# Autoverse
+
+Command-line client for Autoverse literature search. The default API is `https://app.autoverse.nz`.
+
+```bash
+pipx install autoverse
+autoverse login
+autoverse search "HER2-low breast cancer" --domain medicine --limit 5
+autoverse resolve doi:10.4143/crt.2023.1138
+autoverse usage
+```
+
+Sign-in opens a browser for GitHub authorization. Headless or CI environments store a platform key:
+
+```bash
+autoverse login --token sr_live_...
+# or
+export AUTOVERSE_API_KEY="sr_live_..."
+```
+
+Coding assistants should use the hosted MCP at `https://app.autoverse.nz/mcp` with `Authorization: Bearer <platform key>`. Do not install `npx @autoverse/mcp-server`. Do not install `autoverse-cli` from PyPI — that name belongs to a different project.
+
+Requires Python 3.12+.

autoverse-0.1.0/README.md

@@ -0,0 +1,23 @@
+# Autoverse
+
+Command-line client for Autoverse literature search. The default API is `https://app.autoverse.nz`.
+
+```bash
+pipx install autoverse
+autoverse login
+autoverse search "HER2-low breast cancer" --domain medicine --limit 5
+autoverse resolve doi:10.4143/crt.2023.1138
+autoverse usage
+```
+
+Sign-in opens a browser for GitHub authorization. Headless or CI environments store a platform key:
+
+```bash
+autoverse login --token sr_live_...
+# or
+export AUTOVERSE_API_KEY="sr_live_..."
+```
+
+Coding assistants should use the hosted MCP at `https://app.autoverse.nz/mcp` with `Authorization: Bearer <platform key>`. Do not install `npx @autoverse/mcp-server`. Do not install `autoverse-cli` from PyPI — that name belongs to a different project.
+
+Requires Python 3.12+.

autoverse-0.1.0/pyproject.toml

@@ -0,0 +1,44 @@
+[build-system]
+requires = ["setuptools>=75", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "autoverse"
+version = "0.1.0"
+description = "Command-line client for Autoverse literature search"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+  "httpx>=0.27,<1",
+  "keyring>=25,<26",
+  "mcp>=2,<3",
+  "pydantic>=2.10,<3",
+  "typer>=0.27,<1",
+  "uvicorn[standard]>=0.32,<1",
+]
+
+[project.urls]
+Homepage = "https://app.autoverse.nz"
+Documentation = "https://app.autoverse.nz/#/docs/cli"
+
+[project.optional-dependencies]
+test = [
+  "pytest>=8.3,<9",
+  "pytest-asyncio>=0.25,<1",
+]
+
+[project.scripts]
+autoverse = "autoverse.cli:main"
+autoverse-mcp = "autoverse.mcp_server:main"
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]
+include = ["autoverse"]
+
+[tool.pytest.ini_options]
+pythonpath = ["src"]
+testpaths = ["tests"]
+asyncio_mode = "auto"

autoverse-0.1.0/setup.cfg

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

autoverse-0.1.0/src/autoverse/__init__.py

@@ -0,0 +1,5 @@
+from __future__ import annotations
+
+__version__ = "0.1.0"
+
+DEFAULT_API_BASE = "https://app.autoverse.nz"

autoverse-0.1.0/src/autoverse/__main__.py

@@ -0,0 +1,4 @@
+from autoverse.cli import main
+
+if __name__ == "__main__":
+    main()

autoverse-0.1.0/src/autoverse/_log.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+import logging
+import sys
+from typing import Any
+
+_REDACT_KEYS = frozenset(
+    {
+        "code",
+        "state",
+        "token",
+        "access_token",
+        "refresh_token",
+        "authorization",
+        "code_verifier",
+        "code_challenge",
+        "api_key",
+        "password",
+        "secret",
+    }
+)
+
+
+def configure_logging(*, quiet: bool = False) -> None:
+    """Send process logs to stderr only. stdout stays for tables and JSON."""
+
+    handler = logging.StreamHandler(sys.stderr)
+    handler.setFormatter(logging.Formatter("%(levelname)s %(name)s %(message)s"))
+    root = logging.getLogger("autoverse")
+    root.handlers.clear()
+    root.addHandler(handler)
+    root.setLevel(logging.WARNING if quiet else logging.INFO)
+    root.propagate = False
+
+
+def event(name: str, **fields: Any) -> str:
+    parts = [name]
+    for key, value in fields.items():
+        if value is None:
+            continue
+        if key in _REDACT_KEYS:
+            continue
+        parts.append(f"{key}={value}")
+    return " ".join(parts)

autoverse-0.1.0/src/autoverse/cli.py

@@ -0,0 +1,273 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Annotated, Any
+
+import typer
+
+from autoverse._log import configure_logging
+from autoverse.client import AutoverseClient
+from autoverse.credentials import CredentialStore
+from autoverse.errors import AutoverseError, UsageError
+from autoverse import login as login_flow
+from autoverse.render import emit_error, emit_json, papers_table, response_data, usage_text
+
+app = typer.Typer(no_args_is_help=True, add_completion=False)
+mcp_app = typer.Typer(no_args_is_help=True, add_completion=False)
+app.add_typer(mcp_app, name="mcp")
+
+
+@dataclass(slots=True)
+class AppContext:
+    json_output: bool
+    api_base: str | None
+    api_key: str | None
+    profile: str
+    quiet: bool
+
+
+def _client(ctx: typer.Context) -> AutoverseClient:
+    state: AppContext = ctx.obj
+    return AutoverseClient(
+        api_base=state.api_base,
+        api_key=state.api_key,
+        credentials=CredentialStore(profile=state.profile),
+    )
+
+
+def _emit(ctx: typer.Context, payload: dict[str, Any], *, human: str) -> None:
+    data, request_id = response_data(payload) if isinstance(payload, dict) else (payload, None)
+    if ctx.obj.json_output:
+        emit_json(data, request_id=request_id)
+        return
+    typer.echo(human)
+
+
+@app.callback()
+def _root(
+    ctx: typer.Context,
+    json_output: Annotated[bool, typer.Option("--json", help="Write machine-readable JSON to stdout")] = False,
+    api_base: Annotated[str | None, typer.Option("--api-base", envvar="AUTOVERSE_API_BASE")] = None,
+    api_key: Annotated[str | None, typer.Option("--api-key", envvar="AUTOVERSE_API_KEY")] = None,
+    profile: Annotated[str, typer.Option("--profile")] = "default",
+    quiet: Annotated[bool, typer.Option("--quiet")] = False,
+) -> None:
+    configure_logging(quiet=quiet)
+    ctx.obj = AppContext(
+        json_output=json_output,
+        api_base=api_base,
+        api_key=api_key,
+        profile=profile,
+        quiet=quiet,
+    )
+
+
+@app.command()
+def login(
+    ctx: typer.Context,
+    no_browser: Annotated[bool, typer.Option("--no-browser")] = False,
+    token: Annotated[str | None, typer.Option("--token")] = None,
+) -> None:
+    client = _client(ctx)
+    try:
+        if token:
+            stored = client.login_with_api_key(token)
+            _emit(ctx, {"api_base": stored.api_base}, human="API key stored. You can search now.")
+            return
+        payload = login_flow.authorize(client, open_browser=not no_browser)
+        email = ((payload.get("user") or {}) or {}).get("email") or "signed in"
+        _emit(ctx, payload, human=f"Logged in as {email}.")
+    except AutoverseError as exc:
+        emit_error(exc, as_json=ctx.obj.json_output)
+        raise typer.Exit(exc.exit_code) from exc
+
+
+@app.command()
+def logout(
+    ctx: typer.Context,
+    all_sessions: Annotated[bool, typer.Option("--all")] = False,
+) -> None:
+    client = _client(ctx)
+    try:
+        client.logout(all_sessions=all_sessions)
+        _emit(ctx, {"status": "logged_out"}, human="Logged out.")
+    except AutoverseError as exc:
+        emit_error(exc, as_json=ctx.obj.json_output)
+        raise typer.Exit(exc.exit_code) from exc
+
+
+@app.command()
+def whoami(ctx: typer.Context) -> None:
+    client = _client(ctx)
+    try:
+        payload = client.whoami()
+        user = payload.get("user") or {}
+        usage = payload.get("usage") or {}
+        human = f"{user.get('email') or 'api-key'}\n{usage_text(usage)}"
+        _emit(ctx, payload, human=human)
+    except AutoverseError as exc:
+        emit_error(exc, as_json=ctx.obj.json_output)
+        raise typer.Exit(exc.exit_code) from exc
+
+
+@app.command()
+def search(
+    ctx: typer.Context,
+    query: str,
+    domain: Annotated[str, typer.Option("--domain")] = "auto",
+    mode: Annotated[str, typer.Option("--mode")] = "auto",
+    year_from: Annotated[int | None, typer.Option("--year-from")] = None,
+    year_to: Annotated[int | None, typer.Option("--year-to")] = None,
+    publication_type: Annotated[list[str] | None, typer.Option("--type")] = None,
+    limit: Annotated[int, typer.Option("--limit")] = 20,
+    cursor: Annotated[str | None, typer.Option("--cursor")] = None,
+) -> None:
+    if not 1 <= limit <= 50:
+        emit_error(UsageError("limit must be between 1 and 50"), as_json=ctx.obj.json_output)
+        raise typer.Exit(2)
+    client = _client(ctx)
+    try:
+        payload = client.search(
+            query,
+            domain=domain,
+            mode=mode,
+            year_from=year_from,
+            year_to=year_to,
+            publication_types=publication_type,
+            limit=limit,
+            cursor=cursor,
+        )
+        data, _ = response_data(payload)
+        items = data.get("items") if isinstance(data, dict) else []
+        _emit(ctx, payload, human=papers_table(items if isinstance(items, list) else []))
+    except AutoverseError as exc:
+        emit_error(exc, as_json=ctx.obj.json_output)
+        raise typer.Exit(exc.exit_code) from exc
+
+
+@app.command()
+def resolve(ctx: typer.Context, identifier: str) -> None:
+    client = _client(ctx)
+    try:
+        payload = client.resolve(identifier)
+        data, _ = response_data(payload)
+        title = data.get("title") if isinstance(data, dict) else identifier
+        _emit(ctx, payload, human=str(title))
+    except AutoverseError as exc:
+        emit_error(exc, as_json=ctx.obj.json_output)
+        raise typer.Exit(exc.exit_code) from exc
+
+
+@app.command()
+def batch(
+    ctx: typer.Context,
+    file: Annotated[Path, typer.Option("-f", "--file")],
+) -> None:
+    identifiers = [line.strip() for line in file.read_text(encoding="utf-8").splitlines() if line.strip()]
+    client = _client(ctx)
+    try:
+        payload = client.batch(identifiers)
+        items = payload.get("items") if isinstance(payload, dict) else []
+        human = "\n".join(
+            f"{item.get('identifier')}  {((item.get('paper') or {}) or {}).get('title') or item.get('error')}"
+            for item in items
+        )
+        _emit(ctx, payload, human=human or "(no items)")
+    except AutoverseError as exc:
+        emit_error(exc, as_json=ctx.obj.json_output)
+        raise typer.Exit(exc.exit_code) from exc
+
+
+@app.command()
+def authors(ctx: typer.Context, query: str) -> None:
+    client = _client(ctx)
+    try:
+        payload = client.authors(query)
+        items = payload.get("items") if isinstance(payload, dict) else []
+        human = "\n".join(str(item.get("name") or item) for item in items)
+        _emit(ctx, payload, human=human or "(no authors)")
+    except AutoverseError as exc:
+        emit_error(exc, as_json=ctx.obj.json_output)
+        raise typer.Exit(exc.exit_code) from exc
+
+
+@app.command()
+def usage(ctx: typer.Context) -> None:
+    client = _client(ctx)
+    try:
+        payload = client.usage()
+        extra = ""
+        try:
+            events = client.usage_events(limit=10)
+            rows = events.get("items") or []
+            if rows:
+                extra = "\n" + "\n".join(
+                    f"{item.get('created_at')}  {item.get('price_code')}  {item.get('outcome')}"
+                    for item in rows
+                )
+        except AutoverseError:
+            extra = ""
+        _emit(ctx, payload, human=usage_text(payload) + extra)
+    except AutoverseError as exc:
+        emit_error(exc, as_json=ctx.obj.json_output)
+        raise typer.Exit(exc.exit_code) from exc
+
+
+@app.command()
+def api(
+    ctx: typer.Context,
+    path: str,
+    method: Annotated[str, typer.Option("-X")] = "GET",
+    field: Annotated[list[str] | None, typer.Option("-f")] = None,
+) -> None:
+    fields: dict[str, str] = {}
+    for item in field or []:
+        if "=" not in item:
+            emit_error(UsageError("use -f key=value"), as_json=ctx.obj.json_output)
+            raise typer.Exit(2)
+        key, value = item.split("=", 1)
+        fields[key] = value
+    client = _client(ctx)
+    try:
+        payload = client.raw(method, path, fields=fields or None)
+        _emit(ctx, payload if isinstance(payload, dict) else {"data": payload}, human=str(payload))
+    except AutoverseError as exc:
+        emit_error(exc, as_json=ctx.obj.json_output)
+        raise typer.Exit(exc.exit_code) from exc
+
+
+@mcp_app.command("serve")
+def mcp_serve(
+    host: Annotated[str, typer.Option("--host")] = "127.0.0.1",
+    port: Annotated[int, typer.Option("--port")] = 8091,
+    api_base: Annotated[str | None, typer.Option("--api-base")] = None,
+    toolset: Annotated[str, typer.Option("--toolset")] = "default",
+) -> None:
+    from autoverse.hosted_mcp import serve
+
+    try:
+        serve(host=host, port=port, api_base=api_base, toolset=toolset)
+    except UsageError as exc:
+        emit_error(exc, as_json=False)
+        raise typer.Exit(exc.exit_code) from exc
+
+
+@mcp_app.command("install")
+def mcp_install(
+    ctx: typer.Context,
+    host: str,
+    directory: Annotated[Path | None, typer.Option("--dir")] = None,
+) -> None:
+    from autoverse.mcp_server import write_host_config
+
+    try:
+        path = write_host_config(host, directory=directory)
+        _emit(ctx, {"path": str(path), "host": host}, human=f"Wrote {path}")
+    except AutoverseError as exc:
+        emit_error(exc, as_json=ctx.obj.json_output)
+        raise typer.Exit(exc.exit_code) from exc
+
+
+def main() -> None:
+    app()