strawhub 0.1.1__tar.gz

strawhub-0.1.1/.gitignore

@@ -0,0 +1,26 @@
+node_modules/
+dist/
+.output/
+.vinxi/
+.convex/
+*.local
+.env
+.env.*
+!.env.example
+app.config.*
+coverage/
+.claude/
+.tanstack/
+.DS_Store
+
+# Playwright
+test-results/
+playwright-report/
+.vercel
+
+# Python CLI
+__pycache__/
+*.pyc
+*.egg-info/
+cli/dist/
+cli/.venv/

strawhub-0.1.1/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: strawhub
+Version: 0.1.1
+Summary: CLI for the StrawHub agent skill and role registry
+Requires-Python: >=3.10
+Requires-Dist: click>=8.1
+Requires-Dist: httpx>=0.27
+Requires-Dist: rich>=13.0
+Provides-Extra: test
+Requires-Dist: pytest-cov>=4.0; extra == 'test'
+Requires-Dist: pytest>=7.0; extra == 'test'

strawhub-0.1.1/pyproject.toml

@@ -0,0 +1,33 @@
+[project]
+name = "strawhub"
+dynamic = ["version"]
+description = "CLI for the StrawHub agent skill and role registry"
+requires-python = ">=3.10"
+dependencies = [
+    "click>=8.1",
+    "httpx>=0.27",
+    "rich>=13.0",
+]
+
+[project.scripts]
+strawhub = "strawhub.cli:cli"
+
+[project.optional-dependencies]
+test = [
+    "pytest>=7.0",
+    "pytest-cov>=4.0",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.version]
+path = "src/strawhub/__init__.py"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/strawhub"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["src"]

strawhub-0.1.1/src/strawhub/__init__.py

@@ -0,0 +1,3 @@
+"""StrawHub CLI - discover, publish, and install agent skills and roles."""
+
+__version__ = "0.1.1"

strawhub-0.1.1/src/strawhub/cli.py

@@ -0,0 +1,27 @@
+import click
+
+from strawhub import __version__
+from strawhub.commands.login import login
+from strawhub.commands.whoami import whoami
+from strawhub.commands.search import search
+from strawhub.commands.info import info
+from strawhub.commands.list import list_cmd
+from strawhub.commands.install import install
+from strawhub.commands.uninstall import uninstall
+from strawhub.commands.resolve_cmd import resolve_cmd
+
+
+@click.group()
+@click.version_option(version=__version__, prog_name="strawhub")
+def cli():
+    """StrawHub CLI - discover and install agent skills and roles."""
+
+
+cli.add_command(login)
+cli.add_command(whoami)
+cli.add_command(search)
+cli.add_command(info)
+cli.add_command(list_cmd, name="list")
+cli.add_command(install)
+cli.add_command(uninstall)
+cli.add_command(resolve_cmd, name="resolve")

strawhub-0.1.1/src/strawhub/client.py

@@ -0,0 +1,145 @@
+import httpx
+
+from strawhub.config import get_api_url, get_token
+from strawhub.errors import AuthError, NotFoundError, RateLimitError, APIError, StrawHubError
+
+
+class StrawHubClient:
+    """HTTP client for the StrawHub API."""
+
+    def __init__(self, token: str | None = None, api_url: str | None = None):
+        self.api_url = api_url or get_api_url()
+        self.token = token or get_token()
+        self._client = httpx.Client(
+            base_url=self.api_url,
+            timeout=30.0,
+            headers=self._build_headers(),
+        )
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *args):
+        self.close()
+
+    def _build_headers(self) -> dict:
+        headers = {"Accept": "application/json"}
+        if self.token:
+            headers["Authorization"] = f"Bearer {self.token}"
+        return headers
+
+    def _request(self, method: str, url: str, **kwargs) -> httpx.Response:
+        try:
+            return self._client.request(method, url, **kwargs)
+        except httpx.ConnectError:
+            raise StrawHubError(
+                f"Could not connect to {self.api_url}. "
+                "Check your network or set STRAWHUB_API_URL."
+            )
+        except httpx.TimeoutException:
+            raise StrawHubError(f"Request to {self.api_url} timed out.")
+
+    def _parse_json(self, resp: httpx.Response) -> dict:
+        content_type = resp.headers.get("content-type", "")
+        if "application/json" not in content_type and "text/html" in content_type:
+            raise StrawHubError(
+                f"Server returned HTML instead of JSON. "
+                f"Is STRAWHUB_API_URL set to the Convex site URL?"
+            )
+        try:
+            return resp.json()
+        except Exception:
+            raise StrawHubError(f"Unexpected response from server: {resp.text[:200]}")
+
+    def _handle_response(self, resp: httpx.Response) -> dict:
+        if resp.status_code == 401:
+            msg = "Unauthorized"
+            try:
+                msg = resp.json().get("error", msg)
+            except Exception:
+                pass
+            raise AuthError(msg)
+        if resp.status_code == 404:
+            msg = "Not found"
+            try:
+                msg = resp.json().get("error", msg)
+            except Exception:
+                pass
+            raise NotFoundError(msg)
+        if resp.status_code == 429:
+            retry = int(resp.headers.get("Retry-After", "60"))
+            raise RateLimitError(retry)
+        if resp.status_code >= 400:
+            msg = resp.text
+            try:
+                msg = resp.json().get("error", msg)
+            except Exception:
+                pass
+            raise APIError(resp.status_code, msg)
+        return self._parse_json(resp)
+
+    def whoami(self) -> dict:
+        resp = self._request("GET","/api/v1/whoami")
+        return self._handle_response(resp)
+
+    def search(self, query: str, kind: str = "all", limit: int = 20) -> dict:
+        resp = self._request("GET",
+            "/api/v1/search", params={"q": query, "kind": kind, "limit": limit}
+        )
+        return self._handle_response(resp)
+
+    def list_skills(self, limit: int = 50, sort: str = "updated") -> dict:
+        resp = self._request("GET",
+            "/api/v1/skills", params={"limit": limit, "sort": sort}
+        )
+        return self._handle_response(resp)
+
+    def list_roles(self, limit: int = 50, sort: str = "updated") -> dict:
+        resp = self._request("GET",
+            "/api/v1/roles", params={"limit": limit, "sort": sort}
+        )
+        return self._handle_response(resp)
+
+    def get_skill(self, slug: str) -> dict:
+        resp = self._request("GET",f"/api/v1/skills/{slug}")
+        return self._handle_response(resp)
+
+    def get_role(self, slug: str) -> dict:
+        resp = self._request("GET",f"/api/v1/roles/{slug}")
+        return self._handle_response(resp)
+
+    def get_skill_file(self, slug: str, path: str = "SKILL.md") -> str:
+        resp = self._request("GET",
+            f"/api/v1/skills/{slug}/file", params={"path": path}
+        )
+        if resp.status_code >= 400:
+            self._handle_response(resp)
+        return resp.text
+
+    def get_role_file(self, slug: str, path: str = "ROLE.md") -> str:
+        resp = self._request("GET",
+            f"/api/v1/roles/{slug}/file", params={"path": path}
+        )
+        if resp.status_code >= 400:
+            self._handle_response(resp)
+        return resp.text
+
+    def resolve_role_deps(self, slug: str) -> dict:
+        resp = self._request("GET",f"/api/v1/roles/{slug}/resolve")
+        return self._handle_response(resp)
+
+    def get_info(self, slug: str, kind: str | None = None) -> tuple[str, dict]:
+        """Get info for a slug, auto-detecting kind if not specified.
+        Returns (kind, detail_dict)."""
+        if kind == "skill":
+            return ("skill", self.get_skill(slug))
+        if kind == "role":
+            return ("role", self.get_role(slug))
+        # Auto-detect: try skill first, then role
+        try:
+            return ("skill", self.get_skill(slug))
+        except NotFoundError:
+            return ("role", self.get_role(slug))
+
+    def close(self):
+        self._client.close()

strawhub-0.1.1/src/strawhub/commands/info.py

@@ -0,0 +1,27 @@
+import click
+
+from strawhub.client import StrawHubClient
+from strawhub.display import print_detail, print_error
+from strawhub.errors import NotFoundError, StrawHubError
+
+
+@click.command()
+@click.argument("slug")
+@click.option(
+    "--kind",
+    type=click.Choice(["skill", "role"]),
+    default=None,
+    help="Specify kind (auto-detects if omitted)",
+)
+def info(slug, kind):
+    """Show detailed information about a skill or role."""
+    with StrawHubClient() as client:
+        try:
+            detected_kind, detail = client.get_info(slug, kind=kind)
+            print_detail(detected_kind, detail)
+        except NotFoundError:
+            print_error(f"'{slug}' not found as a skill or role.")
+            raise SystemExit(1)
+        except StrawHubError as e:
+            print_error(str(e))
+            raise SystemExit(1)

strawhub-0.1.1/src/strawhub/commands/install.py

@@ -0,0 +1,207 @@
+from pathlib import Path
+
+import click
+
+from strawhub.client import StrawHubClient
+from strawhub.display import print_success, print_error, console
+from strawhub.errors import NotFoundError, StrawHubError, DependencyError
+from strawhub.frontmatter import parse_frontmatter
+from strawhub.lockfile import Lockfile, PackageRef
+from strawhub.paths import (
+    get_root,
+    get_local_root,
+    get_global_root,
+    get_lockfile_path,
+    get_package_dir,
+    package_exists,
+)
+from strawhub.version_spec import parse_dependency_spec
+
+
+@click.command()
+@click.argument("slug")
+@click.option(
+    "--kind",
+    type=click.Choice(["skill", "role"]),
+    default=None,
+    help="Specify kind (auto-detects if omitted)",
+)
+@click.option(
+    "--global",
+    "is_global",
+    is_flag=True,
+    default=False,
+    help="Install to global directory (~/.strawpot or STRAWPOT_HOME)",
+)
+def install(slug, kind, is_global):
+    """Install a skill or role with all dependencies."""
+    root = get_root(is_global)
+    lockfile = Lockfile.load(get_lockfile_path(root))
+
+    with StrawHubClient() as client:
+        try:
+            detected_kind, detail = client.get_info(slug, kind=kind)
+            lv = detail.get("latestVersion")
+            if not lv:
+                print_error(f"'{slug}' has no published versions.")
+                raise SystemExit(1)
+
+            version = lv["version"]
+            root_ref = PackageRef(kind=detected_kind, slug=slug, version=version)
+
+            # Check if already installed in either scope
+            if _already_installed(root_ref):
+                scope = _installed_scope(root_ref)
+                console.print(
+                    f"'{slug}' v{version} is already installed ({scope})."
+                )
+                # Still register as direct install if not already
+                if not lockfile.is_direct_install(root_ref.key):
+                    lockfile.add_package(root_ref)
+                    lockfile.add_direct_install(root_ref)
+                    lockfile.save()
+                return
+
+            # Resolve dependencies
+            dep_list = _resolve_deps(client, detected_kind, slug, detail)
+
+            # Install dependencies first (leaves before root)
+            for dep in dep_list:
+                dep_ref = PackageRef(
+                    kind=dep["kind"], slug=dep["slug"], version=dep["version"]
+                )
+                if _already_installed(dep_ref):
+                    # Register in lockfile if in our scope but not tracked
+                    if package_exists(root, dep_ref.kind, dep_ref.slug, dep_ref.version):
+                        lockfile.add_package(dep_ref, dependent=root_ref)
+                    console.print(
+                        f"  Skipped {dep['kind']} '{dep['slug']}' v{dep['version']}"
+                        " (already installed)"
+                    )
+                    continue
+
+                _download_package(client, dep["kind"], dep["slug"], dep["version"], root)
+                lockfile.add_package(dep_ref, dependent=root_ref)
+                console.print(
+                    f"  Installed {dep['kind']} '{dep['slug']}' v{dep['version']}"
+                )
+
+            # Install the root package
+            _download_package(client, detected_kind, slug, version, root)
+            lockfile.add_package(root_ref)
+            lockfile.add_direct_install(root_ref)
+            lockfile.save()
+            print_success(f"Installed {detected_kind} '{slug}' v{version}")
+
+        except NotFoundError:
+            print_error(f"'{slug}' not found.")
+            raise SystemExit(1)
+        except (StrawHubError, DependencyError) as e:
+            print_error(str(e))
+            raise SystemExit(1)
+
+
+def _resolve_deps(
+    client: StrawHubClient, kind: str, slug: str, detail: dict
+) -> list[dict]:
+    """Resolve all transitive dependencies for a package.
+
+    For roles, uses the server-side /resolve endpoint.
+    For skills, resolves client-side by parsing SKILL.md frontmatter.
+    """
+    if kind == "role":
+        console.print("Resolving dependencies...")
+        resolved = client.resolve_role_deps(slug)
+        return resolved.get("dependencies", [])
+    else:
+        # Skills: resolve client-side via frontmatter parsing
+        dep_list: list[dict] = []
+        visited: set[str] = set()
+        _resolve_skill_deps(client, slug, visited, dep_list)
+        # Remove the root skill itself from the dep list (it was added by recursion)
+        dep_list = [d for d in dep_list if d["slug"] != slug]
+        if dep_list:
+            console.print("Resolving dependencies...")
+        return dep_list
+
+
+def _resolve_skill_deps(
+    client: StrawHubClient,
+    slug: str,
+    visited: set[str],
+    dep_list: list[dict],
+) -> None:
+    """Recursively resolve skill dependencies by fetching SKILL.md and parsing frontmatter."""
+    if slug in visited:
+        return
+    visited.add(slug)
+
+    try:
+        _, detail = client.get_info(slug, kind="skill")
+    except NotFoundError:
+        raise DependencyError(f"Dependency skill '{slug}' not found in registry")
+
+    lv = detail.get("latestVersion")
+    if not lv:
+        raise DependencyError(f"Dependency skill '{slug}' has no published versions")
+
+    # Get the SKILL.md content and parse frontmatter for dependencies
+    deps = detail.get("dependencies", {})
+    skill_deps = deps.get("skills", [])
+
+    # Also check latestVersion.dependencies if top-level is empty
+    if not skill_deps and lv.get("dependencies"):
+        skill_deps = lv["dependencies"].get("skills", [])
+
+    # Recurse into transitive deps first (DFS, leaves first)
+    for dep_spec_str in skill_deps:
+        spec = parse_dependency_spec(dep_spec_str)
+        _resolve_skill_deps(client, spec.slug, visited, dep_list)
+
+    dep_list.append({
+        "kind": "skill",
+        "slug": slug,
+        "version": lv["version"],
+    })
+
+
+def _already_installed(ref: PackageRef) -> bool:
+    """Check if a package exists in either local or global scope."""
+    return (
+        package_exists(get_local_root(), ref.kind, ref.slug, ref.version)
+        or package_exists(get_global_root(), ref.kind, ref.slug, ref.version)
+    )
+
+
+def _installed_scope(ref: PackageRef) -> str:
+    """Return 'local' or 'global' indicating where the package is installed."""
+    if package_exists(get_local_root(), ref.kind, ref.slug, ref.version):
+        return "local"
+    return "global"
+
+
+def _download_package(
+    client: StrawHubClient,
+    kind: str,
+    slug: str,
+    version: str,
+    root: Path,
+) -> None:
+    """Download a package's files into root/{kind}s/{slug}-{version}/."""
+    target_dir = get_package_dir(root, kind, slug, version)
+    target_dir.mkdir(parents=True, exist_ok=True)
+
+    # Fetch detail to get file list
+    _, detail = client.get_info(slug, kind=kind)
+    lv = detail.get("latestVersion", {})
+
+    for f in lv.get("files", []):
+        file_path = f["path"]
+        if kind == "skill":
+            content = client.get_skill_file(slug, path=file_path)
+        else:
+            content = client.get_role_file(slug, path=file_path)
+
+        out_file = target_dir / file_path
+        out_file.parent.mkdir(parents=True, exist_ok=True)
+        out_file.write_text(content)

strawhub-0.1.1/src/strawhub/commands/list.py

@@ -0,0 +1,41 @@
+import click
+
+from strawhub.client import StrawHubClient
+from strawhub.display import print_list_table, print_error, console
+from strawhub.errors import StrawHubError
+
+
+@click.command("list")
+@click.option(
+    "--kind",
+    type=click.Choice(["skills", "roles", "all"]),
+    default="all",
+)
+@click.option("--limit", type=int, default=50, help="Max results (1-200)")
+@click.option(
+    "--sort",
+    type=click.Choice(["updated", "downloads", "stars"]),
+    default="updated",
+)
+def list_cmd(kind, limit, sort):
+    """List skills and/or roles."""
+    with StrawHubClient() as client:
+        try:
+            if kind in ("skills", "all"):
+                data = client.list_skills(limit=limit, sort=sort)
+                items = data.get("items", [])
+                if items:
+                    print_list_table(items, "skill")
+                elif kind == "skills":
+                    console.print("No skills found.")
+
+            if kind in ("roles", "all"):
+                data = client.list_roles(limit=limit, sort=sort)
+                items = data.get("items", [])
+                if items:
+                    print_list_table(items, "role")
+                elif kind == "roles":
+                    console.print("No roles found.")
+        except StrawHubError as e:
+            print_error(str(e))
+            raise SystemExit(1)

strawhub-0.1.1/src/strawhub/commands/login.py

@@ -0,0 +1,28 @@
+import click
+
+from strawhub.client import StrawHubClient
+from strawhub.config import set_token
+from strawhub.display import print_user_info, print_success, print_error
+from strawhub.errors import StrawHubError
+
+
+@click.command()
+def login():
+    """Authenticate with your StrawHub API token."""
+    click.echo("Get your API token from: https://strawhub.dev/settings")
+    token = click.prompt("API token", hide_input=True)
+
+    if not token.startswith("sh_"):
+        print_error("Invalid token format. Tokens start with 'sh_'.")
+        raise SystemExit(1)
+
+    with StrawHubClient(token=token) as client:
+        try:
+            user = client.whoami()
+        except StrawHubError as e:
+            print_error(str(e))
+            raise SystemExit(1)
+
+    set_token(token)
+    print_success("Logged in successfully!")
+    print_user_info(user)

strawhub-0.1.1/src/strawhub/commands/resolve_cmd.py

@@ -0,0 +1,56 @@
+import json
+
+import click
+
+from strawhub.display import print_error, console
+from strawhub.errors import DependencyError
+from strawhub.resolver import resolve
+
+
+@click.command("resolve")
+@click.argument("slug")
+@click.option(
+    "--kind",
+    type=click.Choice(["skill", "role"]),
+    default=None,
+    help="Specify kind (auto-detects if omitted)",
+)
+@click.option(
+    "--version",
+    "ver",
+    default=None,
+    help="Resolve a specific version",
+)
+@click.option(
+    "--global",
+    "is_global",
+    is_flag=True,
+    default=False,
+    help="Only search global directory",
+)
+def resolve_cmd(slug, kind, ver, is_global):
+    """Resolve a slug to its installed path and dependency paths.
+
+    Outputs JSON with the resolved package and all transitive
+    dependencies, including absolute file paths.
+    """
+    from strawhub.paths import get_global_root, get_local_root
+
+    try:
+        if is_global:
+            # Only search global scope
+            gr = get_global_root()
+            result = resolve(
+                slug,
+                kind=kind,
+                version=ver,
+                local_root=gr,  # Use global as both to skip local
+                global_root=gr,
+            )
+        else:
+            result = resolve(slug, kind=kind, version=ver)
+
+        console.print_json(json.dumps(result))
+    except DependencyError as e:
+        print_error(str(e))
+        raise SystemExit(1)

strawhub-0.1.1/src/strawhub/commands/search.py

@@ -0,0 +1,25 @@
+import click
+
+from strawhub.client import StrawHubClient
+from strawhub.display import print_search_results, print_error, console
+from strawhub.errors import StrawHubError
+
+
+@click.command()
+@click.argument("query")
+@click.option("--kind", type=click.Choice(["skill", "role", "all"]), default="all")
+@click.option("--limit", type=int, default=20, help="Max results (1-100)")
+def search(query, kind, limit):
+    """Search for skills and roles."""
+    with StrawHubClient() as client:
+        try:
+            data = client.search(query, kind=kind, limit=limit)
+            results = data.get("results", [])
+            if not results:
+                console.print("No results found.")
+                return
+            print_search_results(results)
+            console.print(f"\n{data['count']} result(s) found.")
+        except StrawHubError as e:
+            print_error(str(e))
+            raise SystemExit(1)