dhub-cli 0.1.0__tar.gz

dhub_cli-0.1.0/.gitignore

@@ -0,0 +1,22 @@
+__pycache__/
+*.py[cod]
+*$py.class
+*.egg-info/
+dist/
+build/
+.eggs/
+*.egg
+
+.env
+.venv/
+venv/
+
+.pytest_cache/
+.mypy_cache/
+.coverage
+htmlcov/
+
+*.db
+*.sqlite3
+
+.DS_Store

dhub_cli-0.1.0/PKG-INFO

@@ -0,0 +1,78 @@
+Metadata-Version: 2.4
+Name: dhub-cli
+Version: 0.1.0
+Summary: The CLI package manager for AI agent skills
+Project-URL: Homepage, https://github.com/lfiaschi/decision-hub
+Project-URL: Repository, https://github.com/lfiaschi/decision-hub
+Project-URL: Issues, https://github.com/lfiaschi/decision-hub/issues
+Author-email: Luca Fiaschi <luca.fiaschi@gmail.com>
+License-Expression: MIT
+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 :: Software Development :: Libraries
+Requires-Python: >=3.11
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: pyyaml>=6.0.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: typer[all]>=0.12.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# dhub
+
+The CLI package manager for AI agent skills.
+
+`dhub` lets you publish, discover, and install **Skills** — modular capabilities (code + prompts) that agents like Claude, Cursor, and Gemini can use.
+
+## Installation
+
+```bash
+# Via uv
+uv tool install dhub
+
+# Via pipx
+pipx install dhub
+```
+
+## Quick Start
+
+```bash
+# Authenticate via GitHub
+dhub login
+
+# Publish a skill
+dhub publish --org my-org --name my-skill --version 1.0.0
+
+# Install a skill
+dhub install my-org/my-skill
+
+# Search for skills
+dhub ask "analyze A/B test results"
+
+# Run a skill locally
+dhub run my-org/my-skill
+```
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `dhub login` | Authenticate via GitHub Device Flow |
+| `dhub publish` | Publish a skill to the registry |
+| `dhub install` | Install a skill |
+| `dhub list` | List installed skills |
+| `dhub delete` | Delete a skill from the registry |
+| `dhub run` | Run a locally installed skill |
+| `dhub ask` | Natural language skill search |
+| `dhub org` | Manage organizations |
+| `dhub keys` | Manage API keys for evaluations |
+
+## Documentation
+
+See the [main repository](https://github.com/lfiaschi/decision-hub) for full documentation.

dhub_cli-0.1.0/README.md

@@ -0,0 +1,52 @@
+# dhub
+
+The CLI package manager for AI agent skills.
+
+`dhub` lets you publish, discover, and install **Skills** — modular capabilities (code + prompts) that agents like Claude, Cursor, and Gemini can use.
+
+## Installation
+
+```bash
+# Via uv
+uv tool install dhub
+
+# Via pipx
+pipx install dhub
+```
+
+## Quick Start
+
+```bash
+# Authenticate via GitHub
+dhub login
+
+# Publish a skill
+dhub publish --org my-org --name my-skill --version 1.0.0
+
+# Install a skill
+dhub install my-org/my-skill
+
+# Search for skills
+dhub ask "analyze A/B test results"
+
+# Run a skill locally
+dhub run my-org/my-skill
+```
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `dhub login` | Authenticate via GitHub Device Flow |
+| `dhub publish` | Publish a skill to the registry |
+| `dhub install` | Install a skill |
+| `dhub list` | List installed skills |
+| `dhub delete` | Delete a skill from the registry |
+| `dhub run` | Run a locally installed skill |
+| `dhub ask` | Natural language skill search |
+| `dhub org` | Manage organizations |
+| `dhub keys` | Manage API keys for evaluations |
+
+## Documentation
+
+See the [main repository](https://github.com/lfiaschi/decision-hub) for full documentation.

dhub_cli-0.1.0/pyproject.toml

@@ -0,0 +1,50 @@
+[project]
+name = "dhub-cli"
+version = "0.1.0"
+description = "The CLI package manager for AI agent skills"
+requires-python = ">=3.11"
+license = "MIT"
+authors = [
+    { name = "Luca Fiaschi", email = "luca.fiaschi@gmail.com" },
+]
+readme = "README.md"
+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 :: Software Development :: Libraries",
+]
+dependencies = [
+    "typer[all]>=0.12.0",
+    "rich>=13.0.0",
+    "httpx>=0.27.0",
+    "pyyaml>=6.0.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0.0",
+]
+
+[project.scripts]
+dhub = "dhub.cli.app:run"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/dhub"]
+
+[project.urls]
+Homepage = "https://github.com/lfiaschi/decision-hub"
+Repository = "https://github.com/lfiaschi/decision-hub"
+Issues = "https://github.com/lfiaschi/decision-hub/issues"
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["src"]

dhub_cli-0.1.0/src/dhub/__init__.py

@@ -0,0 +1 @@
+

dhub_cli-0.1.0/src/dhub/cli/__init__.py

@@ -0,0 +1 @@
+

dhub_cli-0.1.0/src/dhub/cli/app.py

@@ -0,0 +1,35 @@
+"""Main Typer app with subcommand registration."""
+
+import typer
+
+app = typer.Typer(
+    name="dhub",
+    help="Decision Hub - The package manager for AI agent skills",
+    no_args_is_help=True,
+)
+
+# Register top-level commands
+from dhub.cli.auth import login_command  # noqa: E402
+from dhub.cli.registry import delete_command, install_command, list_command, publish_command  # noqa: E402
+from dhub.cli.runtime import run_command  # noqa: E402
+from dhub.cli.search import ask_command  # noqa: E402
+
+app.command("login")(login_command)
+app.command("publish")(publish_command)
+app.command("install")(install_command)
+app.command("list")(list_command)
+app.command("delete")(delete_command)
+app.command("run")(run_command)
+app.command("ask")(ask_command)
+
+# Register subcommand groups
+from dhub.cli.keys import keys_app  # noqa: E402
+from dhub.cli.org import org_app  # noqa: E402
+
+app.add_typer(org_app, name="org")
+app.add_typer(keys_app, name="keys")
+
+
+def run() -> None:
+    """Entry point for the dhub CLI."""
+    app()

dhub_cli-0.1.0/src/dhub/cli/auth.py

@@ -0,0 +1,93 @@
+"""Login via GitHub Device Flow."""
+
+import time
+
+import httpx
+import typer
+from rich.console import Console
+from rich.panel import Panel
+
+console = Console()
+
+
+def login_command(
+    api_url: str = typer.Option(None, "--api-url", help="API URL override"),
+) -> None:
+    """Authenticate with Decision Hub via GitHub."""
+    from dhub.cli.config import CliConfig, get_api_url, save_config
+
+    base_url = api_url or get_api_url()
+
+    # Step 1: Request a device code from the API
+    with httpx.Client() as client:
+        resp = client.post(f"{base_url}/auth/github/code")
+        resp.raise_for_status()
+        data = resp.json()
+
+    device_code: str = data["device_code"]
+    user_code: str = data["user_code"]
+    verification_uri: str = data["verification_uri"]
+    poll_interval: int = data.get("interval", 5)
+
+    # Step 2: Show the user code and URL
+    console.print(
+        Panel(
+            f"Open [bold blue]{verification_uri}[/] and enter code: "
+            f"[bold green]{user_code}[/]",
+            title="GitHub Login",
+        )
+    )
+    console.print("Waiting for authorization...")
+
+    # Step 3: Poll for the token until the user completes the flow
+    token_data = _poll_for_token(base_url, device_code, poll_interval)
+
+    # Step 4: Persist the token
+    new_config = CliConfig(api_url=base_url, token=token_data["access_token"])
+    save_config(new_config)
+
+    console.print(f"[green]Authenticated as @{token_data['username']}[/]")
+
+
+def _poll_for_token(
+    base_url: str,
+    device_code: str,
+    interval: int,
+    timeout_seconds: int = 300,
+) -> dict:
+    """Poll the token endpoint until authorization succeeds or times out.
+
+    Args:
+        base_url: API base URL.
+        device_code: The device code returned from the code request.
+        interval: Seconds to wait between poll attempts.
+        timeout_seconds: Maximum total seconds to wait before giving up.
+
+    Returns:
+        Parsed JSON response containing 'access_token' and 'username'.
+
+    Raises:
+        typer.Exit: If the flow times out or the server rejects the request.
+    """
+    deadline = time.monotonic() + timeout_seconds
+
+    with httpx.Client(timeout=30) as client:
+        while time.monotonic() < deadline:
+            resp = client.post(
+                f"{base_url}/auth/github/token",
+                json={"device_code": device_code},
+            )
+
+            if resp.status_code == 200:
+                return resp.json()
+
+            # 428 means "authorization_pending" -- keep polling
+            if resp.status_code == 428:
+                time.sleep(interval)
+                continue
+
+            # Any other error is fatal
+            resp.raise_for_status()
+
+    console.print("[red]Error: Login timed out. Please try again.[/]")
+    raise typer.Exit(1)

dhub_cli-0.1.0/src/dhub/cli/config.py

@@ -0,0 +1,74 @@
+"""CLI configuration file management for ~/.dhub/config.json."""
+
+import json
+import os
+from dataclasses import asdict, dataclass
+from pathlib import Path
+
+import typer
+
+CONFIG_DIR = Path.home() / ".dhub"
+CONFIG_FILE = CONFIG_DIR / "config.json"
+DEFAULT_API_URL = "https://decision-hub--api.modal.run"
+
+
+@dataclass(frozen=True)
+class CliConfig:
+    """Immutable CLI configuration."""
+
+    api_url: str = DEFAULT_API_URL
+    token: str | None = None
+
+
+def load_config() -> CliConfig:
+    """Load CLI config from ~/.dhub/config.json.
+
+    Returns defaults if the file does not exist or contains
+    incomplete data.
+    """
+    if not CONFIG_FILE.exists():
+        return CliConfig()
+
+    raw = json.loads(CONFIG_FILE.read_text(encoding="utf-8"))
+    return CliConfig(
+        api_url=raw.get("api_url", DEFAULT_API_URL),
+        token=raw.get("token"),
+    )
+
+
+def save_config(config: CliConfig) -> None:
+    """Save CLI config to ~/.dhub/config.json.
+
+    Creates the ~/.dhub directory if it does not already exist.
+    """
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    CONFIG_FILE.write_text(
+        json.dumps(asdict(config), indent=2) + "\n",
+        encoding="utf-8",
+    )
+
+
+def get_api_url() -> str:
+    """Get API URL from the DHUB_API_URL env var, falling back to saved config."""
+    env_url = os.environ.get("DHUB_API_URL")
+    if env_url:
+        return env_url
+    return load_config().api_url
+
+
+def get_token() -> str:
+    """Get the stored auth token.
+
+    Raises:
+        typer.Exit: If no token is stored (user not logged in).
+    """
+    from rich.console import Console
+
+    token = load_config().token
+    if not token:
+        console = Console(stderr=True)
+        console.print(
+            "[red]Error: Not logged in. Run [bold]dhub login[/bold] first.[/]"
+        )
+        raise typer.Exit(1)
+    return token

dhub_cli-0.1.0/src/dhub/cli/keys.py

@@ -0,0 +1,96 @@
+"""API key management commands."""
+
+import httpx
+import typer
+from rich.console import Console
+from rich.table import Table
+
+console = Console()
+keys_app = typer.Typer(help="Manage API keys for agent evals", no_args_is_help=True)
+
+
+def _headers() -> dict[str, str]:
+    """Build authorization headers using the stored token."""
+    from dhub.cli.config import get_token
+
+    return {"Authorization": f"Bearer {get_token()}"}
+
+
+def _api_url() -> str:
+    """Retrieve the configured API URL."""
+    from dhub.cli.config import get_api_url
+
+    return get_api_url()
+
+
+@keys_app.command("add")
+def add_key(
+    key_name: str = typer.Argument(help="Name for the API key"),
+) -> None:
+    """Add an API key (prompts for the value securely)."""
+    key_value = typer.prompt("Enter API key value", hide_input=True)
+
+    if not key_value.strip():
+        console.print("[red]Error: Key value cannot be empty.[/]")
+        raise typer.Exit(1)
+
+    with httpx.Client() as client:
+        resp = client.post(
+            f"{_api_url()}/v1/keys",
+            headers=_headers(),
+            json={"key_name": key_name, "value": key_value},
+        )
+        if resp.status_code == 409:
+            console.print(
+                f"[red]Error: Key '{key_name}' already exists. "
+                "Remove it first with [bold]dhub keys remove[/bold].[/]"
+            )
+            raise typer.Exit(1)
+        resp.raise_for_status()
+
+    console.print(f"[green]Added key: {key_name}[/]")
+
+
+@keys_app.command("list")
+def list_keys() -> None:
+    """List stored API key names."""
+    with httpx.Client() as client:
+        resp = client.get(
+            f"{_api_url()}/v1/keys",
+            headers=_headers(),
+        )
+        resp.raise_for_status()
+        keys = resp.json()
+
+    if not keys:
+        console.print("No API keys stored.")
+        return
+
+    table = Table(title="API Keys")
+    table.add_column("Name", style="cyan")
+    table.add_column("Created", style="dim")
+
+    for key in keys:
+        table.add_row(key.get("key_name", ""), key.get("created_at", ""))
+
+    console.print(table)
+
+
+@keys_app.command("remove")
+def remove_key(
+    key_name: str = typer.Argument(help="Name of the API key to remove"),
+) -> None:
+    """Remove a stored API key."""
+    with httpx.Client() as client:
+        resp = client.delete(
+            f"{_api_url()}/v1/keys/{key_name}",
+            headers=_headers(),
+        )
+        if resp.status_code == 404:
+            console.print(
+                f"[red]Error: Key '{key_name}' not found.[/]"
+            )
+            raise typer.Exit(1)
+        resp.raise_for_status()
+
+    console.print(f"[green]Removed key: {key_name}[/]")

dhub_cli-0.1.0/src/dhub/cli/org.py

@@ -0,0 +1,125 @@
+"""Organization management commands."""
+
+import httpx
+import typer
+from rich.console import Console
+from rich.table import Table
+
+console = Console()
+org_app = typer.Typer(help="Manage organizations", no_args_is_help=True)
+
+
+def _headers() -> dict[str, str]:
+    """Build authorization headers using the stored token."""
+    from dhub.cli.config import get_token
+
+    return {"Authorization": f"Bearer {get_token()}"}
+
+
+def _api_url() -> str:
+    """Retrieve the configured API URL."""
+    from dhub.cli.config import get_api_url
+
+    return get_api_url()
+
+
+@org_app.command("create")
+def create_org(slug: str = typer.Argument(help="Organization slug")) -> None:
+    """Create a new organization."""
+    with httpx.Client() as client:
+        resp = client.post(
+            f"{_api_url()}/v1/orgs",
+            headers=_headers(),
+            json={"slug": slug},
+        )
+        if resp.status_code == 409:
+            console.print(
+                f"[red]Error: Organization '{slug}' already exists.[/]"
+            )
+            raise typer.Exit(1)
+        resp.raise_for_status()
+        data = resp.json()
+
+    console.print(f"[green]Created organization: {data['slug']}[/]")
+
+
+@org_app.command("list")
+def list_orgs() -> None:
+    """List organizations you belong to."""
+    with httpx.Client() as client:
+        resp = client.get(
+            f"{_api_url()}/v1/orgs",
+            headers=_headers(),
+        )
+        resp.raise_for_status()
+        orgs = resp.json()
+
+    if not orgs:
+        console.print("You are not a member of any organizations.")
+        return
+
+    table = Table(title="Organizations")
+    table.add_column("Slug", style="cyan")
+    table.add_column("Role", style="green")
+
+    for org in orgs:
+        table.add_row(org.get("slug", ""), org.get("role", ""))
+
+    console.print(table)
+
+
+@org_app.command("invite")
+def invite_member(
+    org: str = typer.Argument(help="Organization slug"),
+    user: str = typer.Option(..., "--user", help="GitHub username to invite"),
+    role: str = typer.Option(
+        "member", "--role", help="Role: owner, admin, or member"
+    ),
+) -> None:
+    """Invite a user to an organization."""
+    with httpx.Client() as client:
+        resp = client.post(
+            f"{_api_url()}/v1/orgs/{org}/invites",
+            headers=_headers(),
+            json={"invitee_github_username": user, "role": role},
+        )
+        if resp.status_code == 404:
+            console.print(
+                f"[red]Error: Organization '{org}' not found.[/]"
+            )
+            raise typer.Exit(1)
+        if resp.status_code == 403:
+            console.print(
+                "[red]Error: You do not have permission to invite members.[/]"
+            )
+            raise typer.Exit(1)
+        resp.raise_for_status()
+        data = resp.json()
+
+    console.print(
+        f"[green]Invited @{user} to '{org}' as {role}. "
+        f"Invite ID: {data['id']}[/]"
+    )
+
+
+@org_app.command("accept")
+def accept_invite(
+    invite_id: str = typer.Argument(help="Invite ID to accept"),
+) -> None:
+    """Accept an organization invite."""
+    with httpx.Client() as client:
+        resp = client.post(
+            f"{_api_url()}/v1/invites/{invite_id}/accept",
+            headers=_headers(),
+        )
+        if resp.status_code == 404:
+            console.print(
+                f"[red]Error: Invite '{invite_id}' not found.[/]"
+            )
+            raise typer.Exit(1)
+        resp.raise_for_status()
+        data = resp.json()
+
+    console.print(
+        f"[green]Accepted invite. You are now a member of '{data['org_slug']}'.[/]"
+    )