cli-anything-hub 0.1.0__py3-none-any.whl

cli_anything_hub-0.1.0.dist-info/METADATA

@@ -0,0 +1,129 @@
+Metadata-Version: 2.4
+Name: cli-anything-hub
+Version: 0.1.0
+Summary: Package manager for CLI-Anything — browse, install, and manage 40+ agent-native CLI interfaces for GUI applications
+Home-page: https://github.com/HKUDS/CLI-Anything
+Author: HKUDS
+Author-email: hkuds@connect.hku.hk
+License: MIT
+Project-URL: Homepage, https://clianything.cc
+Project-URL: Repository, https://github.com/HKUDS/CLI-Anything
+Project-URL: Bug Tracker, https://github.com/HKUDS/CLI-Anything/issues
+Project-URL: Catalog, https://clianything.cc/SKILL.txt
+Keywords: cli,agent,gui,automation,package-manager,cli-anything
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: System Administrators
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
+Classifier: Topic :: System :: Installation/Setup
+Classifier: Topic :: Utilities
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: click>=8.0
+Requires-Dist: requests>=2.28
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: project-url
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# cli-hub
+
+Package manager for [CLI-Anything](https://github.com/HKUDS/CLI-Anything) — a framework that auto-generates stateful CLI interfaces for GUI applications, making them agent-native.
+
+Browse, install, and manage 40+ CLI harnesses for software like GIMP, Blender, Inkscape, LibreOffice, Audacity, OBS Studio, and more — all from your terminal.
+
+**Web Hub**: [clianything.cc](https://clianything.cc)
+
+## Install
+
+```bash
+pip install cli-anything-hub
+```
+
+## Usage
+
+```bash
+# Browse all available CLIs, grouped by category
+cli-hub list
+
+# Filter by category (image, 3d, video, audio, office, ai, ...)
+cli-hub list -c image
+
+# Search by name, description, or category
+cli-hub search "3d modeling"
+
+# Show details for a CLI
+cli-hub info gimp
+
+# Install a CLI harness
+cli-hub install gimp
+
+# Update a CLI to the latest version
+cli-hub update gimp
+
+# Uninstall a CLI
+cli-hub uninstall gimp
+```
+
+## What gets installed
+
+Each CLI harness is a standalone Python package that wraps a real application (GIMP, Blender, etc.) with a stateful command-line interface. Every harness supports:
+
+- **REPL mode**: `cli-anything-gimp` launches an interactive session
+- **One-shot commands**: `cli-anything-gimp project create --name my-project`
+- **JSON output**: `cli-anything-gimp --json project list` for machine-readable output
+- **Undo/redo**: Stateful project management with full operation history
+
+## For AI agents
+
+cli-hub is designed to be agent-friendly. AI coding agents can:
+
+1. `pip install cli-anything-hub` to get the package manager
+2. `cli-hub search <keyword>` or `cli-hub list --json` to discover tools
+3. `cli-hub install <name>` to install what they need
+4. Use `--json` output for structured data parsing
+
+## Available categories
+
+3D, AI, Audio, Communication, Database, Design, DevOps, Diagrams, Game, GameDev, Generation, Graphics, Image, Music, Network, Office, OSINT, Project Management, Search, Streaming, Testing, Video, Web
+
+## JSON output
+
+All listing commands support `--json` for machine-readable output:
+
+```bash
+cli-hub list --json
+cli-hub search blender --json
+```
+
+## Analytics
+
+cli-hub sends anonymous install/uninstall events to help track adoption (via [Umami](https://umami.is)). No personal data is collected.
+
+Opt out:
+
+```bash
+export CLI_HUB_NO_ANALYTICS=1
+```
+
+## Links
+
+- **Web Hub**: [clianything.cc](https://clianything.cc)
+- **Repository**: [github.com/HKUDS/CLI-Anything](https://github.com/HKUDS/CLI-Anything)
+- **Live Catalog**: [clianything.cc/SKILL.txt](https://clianything.cc/SKILL.txt)

cli_anything_hub-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+cli_hub/__init__.py,sha256=5lilmSqPdheD9dG9k_StNmY8-gU7l13ZJPb7NMxiASU,94
+cli_hub/analytics.py,sha256=miv2qo-cNkYXI8MpPT6bbYxnjSfRHYfSdXIrih_Wv6s,3303
+cli_hub/cli.py,sha256=Y7OADhOCt3gAMzDJgFHBYP0IrXlDF0kKQII1cn7Yc0o,5544
+cli_hub/installer.py,sha256=tErvxDcyWdepCGw6c4Q2SQM4qBYOYEtBFbhHQkxyFuk,3492
+cli_hub/registry.py,sha256=AKo7H74QspbIwi0QeXU8fABZVbNplbry3wtTEx4z_LI,2129
+cli_anything_hub-0.1.0.dist-info/METADATA,sha256=o8CbQ2NGvR1eGNV_bmjJREQgWoEhVKPz-YzPMPZgX9g,4193
+cli_anything_hub-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+cli_anything_hub-0.1.0.dist-info/entry_points.txt,sha256=SiWSD4fNV6Afnf2Wj127-SSMua8RBI3_b-fk1q7hZug,45
+cli_anything_hub-0.1.0.dist-info/top_level.txt,sha256=hrKjMph2zt-FnHl9yi1EJ3kTzR9qYMF3c58c6InJx54,8
+cli_anything_hub-0.1.0.dist-info/RECORD,,

cli_anything_hub-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

cli_anything_hub-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+cli-hub = cli_hub.cli:main

cli_anything_hub-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+cli_hub

cli_hub/__init__.py

@@ -0,0 +1,3 @@
+"""cli-hub — Download, manage, and browse CLI-Anything harnesses."""
+
+__version__ = "0.1.0"

cli_hub/analytics.py

@@ -0,0 +1,111 @@
+"""Lightweight, opt-out-able download event tracking via Umami."""
+
+import os
+import platform
+import threading
+
+import requests
+
+from cli_hub import __version__
+
+UMAMI_URL = "https://cloud.umami.is/api/send"
+WEBSITE_ID = "a076c661-bed1-405c-a522-813794e688b4"
+HOSTNAME = "clianything.cc"
+USER_AGENT = f"Mozilla/5.0 (compatible; cli-hub/{__version__})"
+
+
+def _is_enabled():
+    return os.environ.get("CLI_HUB_NO_ANALYTICS", "").strip() not in ("1", "true", "yes")
+
+
+def _send_event(payload):
+    """Send a single event payload. Blocking — callers should use threads."""
+    try:
+        return requests.post(
+            UMAMI_URL, json=payload, timeout=5,
+            headers={"User-Agent": USER_AGENT},
+        )
+    except Exception:
+        return None  # analytics must never break the user's workflow
+
+
+def track_event(event_name, url="/cli-hub", data=None):
+    """Fire-and-forget event to Umami. Non-blocking, never raises."""
+    if not _is_enabled():
+        return
+
+    payload = {
+        "type": "event",
+        "payload": {
+            "website": WEBSITE_ID,
+            "hostname": HOSTNAME,
+            "url": url,
+            "name": event_name,
+            "data": data or {},
+        },
+    }
+
+    threading.Thread(target=_send_event, args=(payload,), daemon=True).start()
+
+
+def track_install(cli_name, version):
+    """Track a CLI install event — event name includes the CLI for dashboard visibility."""
+    track_event(f"cli-install:{cli_name}", url=f"/cli-hub/install/{cli_name}", data={
+        "cli": cli_name,
+        "version": version,
+        "platform": platform.system().lower(),
+    })
+
+
+def track_uninstall(cli_name):
+    """Track a CLI uninstall event."""
+    track_event(f"cli-uninstall:{cli_name}", url=f"/cli-hub/uninstall/{cli_name}", data={
+        "cli": cli_name,
+    })
+
+
+def track_visit(is_agent=False):
+    """Track a visit-human or visit-agent event, matching the hub website's convention."""
+    event_name = "visit-agent" if is_agent else "visit-human"
+    track_event(event_name, url="/cli-hub", data={
+        "source": "cli-hub",
+        "platform": platform.system().lower(),
+    })
+
+
+def track_first_run():
+    """Send a one-time 'cli-hub-installed' event on first invocation."""
+    from pathlib import Path
+    marker = Path.home() / ".cli-hub" / ".first_run_sent"
+    if marker.exists():
+        return
+    track_event("cli-hub-installed", url="/cli-hub/installed", data={
+        "version": __version__,
+        "platform": platform.system().lower(),
+    })
+    try:
+        marker.parent.mkdir(parents=True, exist_ok=True)
+        marker.write_text(__version__)
+    except Exception:
+        pass
+
+
+def _detect_is_agent():
+    """Detect if cli-hub is likely being invoked by an AI agent."""
+    indicators = [
+        "CLAUDE_CODE",         # Claude Code
+        "CODEX",               # OpenAI Codex
+        "CURSOR_SESSION",      # Cursor
+        "CLINE_SESSION",       # Cline
+        "COPILOT",             # GitHub Copilot
+        "AIDER",               # Aider
+        "CONTINUE_SESSION",    # Continue.dev
+    ]
+    for var in indicators:
+        if os.environ.get(var):
+            return True
+    # Check if stdin is not a terminal (piped / scripted)
+    import sys
+    if not sys.stdin.isatty():
+        return True
+    return False

cli_hub/cli.py

@@ -0,0 +1,168 @@
+"""cli-hub — CLI entry point."""
+
+import click
+
+from cli_hub import __version__
+from cli_hub.registry import fetch_registry, get_cli, search_clis, list_categories
+from cli_hub.installer import install_cli, uninstall_cli, get_installed, update_cli
+from cli_hub.analytics import track_install, track_uninstall, track_visit, track_first_run, _detect_is_agent
+
+
+@click.group(invoke_without_command=True)
+@click.option("--version", is_flag=True, help="Show version.")
+@click.pass_context
+def main(ctx, version):
+    """cli-hub — Download and manage CLI-Anything harnesses."""
+    track_first_run()
+    track_visit(is_agent=_detect_is_agent())
+    if version:
+        click.echo(f"cli-hub {__version__}")
+        return
+    if ctx.invoked_subcommand is None:
+        click.echo(ctx.get_help())
+
+
+@main.command()
+@click.argument("name")
+def install(name):
+    """Install a CLI harness by name."""
+    click.echo(f"Installing {name}...")
+    success, msg = install_cli(name)
+    if success:
+        cli = get_cli(name)
+        track_install(name, cli["version"] if cli else "unknown")
+        click.secho(f"✓ {msg}", fg="green")
+        click.echo(f"  Run it with: {cli['entry_point']}" if cli else "")
+    else:
+        click.secho(f"✗ {msg}", fg="red", err=True)
+        raise SystemExit(1)
+
+
+@main.command()
+@click.argument("name")
+def uninstall(name):
+    """Uninstall a CLI harness by name."""
+    success, msg = uninstall_cli(name)
+    if success:
+        track_uninstall(name)
+        click.secho(f"✓ {msg}", fg="green")
+    else:
+        click.secho(f"✗ {msg}", fg="red", err=True)
+        raise SystemExit(1)
+
+
+@main.command()
+@click.argument("name")
+def update(name):
+    """Update a CLI harness to the latest version."""
+    click.echo(f"Updating {name}...")
+    success, msg = update_cli(name)
+    if success:
+        cli = get_cli(name)
+        track_install(name, cli["version"] if cli else "unknown")
+        click.secho(f"✓ {msg}", fg="green")
+    else:
+        click.secho(f"✗ {msg}", fg="red", err=True)
+        raise SystemExit(1)
+
+
+@main.command("list")
+@click.option("--category", "-c", default=None, help="Filter by category.")
+@click.option("--json", "as_json", is_flag=True, help="Output as JSON.")
+def list_clis(category, as_json):
+    """List all available CLI harnesses."""
+    try:
+        registry = fetch_registry()
+    except Exception as e:
+        click.secho(f"Failed to fetch registry: {e}", fg="red", err=True)
+        raise SystemExit(1)
+
+    clis = registry["clis"]
+    if category:
+        clis = [c for c in clis if c.get("category", "").lower() == category.lower()]
+
+    installed = get_installed()
+
+    if as_json:
+        import json
+        click.echo(json.dumps(clis, indent=2))
+        return
+
+    if not clis:
+        click.echo("No CLIs found." + (f" Category '{category}' may not exist." if category else ""))
+        return
+
+    # Group by category
+    by_cat = {}
+    for cli in clis:
+        cat = cli.get("category", "uncategorized")
+        by_cat.setdefault(cat, []).append(cli)
+
+    for cat in sorted(by_cat):
+        click.secho(f"\n  {cat.upper()}", fg="blue", bold=True)
+        for cli in sorted(by_cat[cat], key=lambda c: c["name"]):
+            marker = click.style(" ●", fg="green") if cli["name"] in installed else "  "
+            name = click.style(f"{cli['name']:20s}", bold=True)
+            desc = cli["description"][:60]
+            click.echo(f"  {marker} {name} {desc}")
+
+    total = len(clis)
+    inst = sum(1 for c in clis if c["name"] in installed)
+    click.echo(f"\n  {total} CLIs available, {inst} installed")
+    cats = list_categories(registry)
+    click.echo(f"  Categories: {', '.join(cats)}")
+
+
+@main.command()
+@click.argument("query")
+@click.option("--json", "as_json", is_flag=True, help="Output as JSON.")
+def search(query, as_json):
+    """Search CLIs by name, description, or category."""
+    results = search_clis(query)
+
+    if as_json:
+        import json
+        click.echo(json.dumps(results, indent=2))
+        return
+
+    if not results:
+        click.echo(f"No CLIs matching '{query}'.")
+        return
+
+    installed = get_installed()
+    for cli in results:
+        marker = click.style("●", fg="green") if cli["name"] in installed else " "
+        name = click.style(cli["name"], bold=True)
+        cat = click.style(f"[{cli.get('category', '')}]", fg="blue")
+        click.echo(f"  {marker} {name} {cat} — {cli['description'][:70]}")
+        click.echo(f"    Install: cli-hub install {cli['name']}")
+
+
+@main.command()
+@click.argument("name")
+def info(name):
+    """Show details for a specific CLI."""
+    cli = get_cli(name)
+    if not cli:
+        click.secho(f"CLI '{name}' not found.", fg="red", err=True)
+        raise SystemExit(1)
+
+    installed = get_installed()
+    is_installed = cli["name"] in installed
+
+    click.secho(f"\n  {cli['display_name']}", bold=True)
+    click.echo(f"  {cli['description']}")
+    click.echo(f"  Category:    {cli.get('category', 'N/A')}")
+    click.echo(f"  Version:     {cli['version']}")
+    click.echo(f"  Requires:    {cli.get('requires') or 'nothing'}")
+    click.echo(f"  Entry point: {cli['entry_point']}")
+    click.echo(f"  Homepage:    {cli.get('homepage', 'N/A')}")
+    click.echo(f"  Contributor: {cli.get('contributor', 'N/A')}")
+    status = click.style("installed", fg="green") if is_installed else "not installed"
+    click.echo(f"  Status:      {status}")
+    click.echo(f"\n  Install: cli-hub install {cli['name']}")
+    click.echo()
+
+
+if __name__ == "__main__":
+    main()

cli_hub/installer.py

@@ -0,0 +1,107 @@
+"""Install, uninstall, and manage CLI-Anything harnesses via pip."""
+
+import json
+import subprocess
+import sys
+from pathlib import Path
+
+from cli_hub.registry import get_cli, fetch_registry
+
+INSTALLED_FILE = Path.home() / ".cli-hub" / "installed.json"
+
+
+def _load_installed():
+    if INSTALLED_FILE.exists():
+        try:
+            return json.loads(INSTALLED_FILE.read_text())
+        except json.JSONDecodeError:
+            pass
+    return {}
+
+
+def _save_installed(data):
+    INSTALLED_FILE.parent.mkdir(parents=True, exist_ok=True)
+    INSTALLED_FILE.write_text(json.dumps(data, indent=2))
+
+
+def install_cli(name):
+    """Install a CLI harness by name. Returns (success, message)."""
+    cli = get_cli(name)
+    if cli is None:
+        return False, f"CLI '{name}' not found in registry. Use 'cli-hub list' to see available CLIs."
+
+    install_cmd = cli["install_cmd"]
+    result = subprocess.run(
+        [sys.executable, "-m", "pip", "install"] + install_cmd.replace("pip install ", "").split(),
+        capture_output=True, text=True
+    )
+
+    if result.returncode == 0:
+        installed = _load_installed()
+        installed[cli["name"]] = {
+            "version": cli["version"],
+            "entry_point": cli["entry_point"],
+            "install_cmd": install_cmd,
+        }
+        _save_installed(installed)
+        return True, f"Installed {cli['display_name']} ({cli['entry_point']})"
+    else:
+        return False, f"pip install failed:\n{result.stderr}"
+
+
+def uninstall_cli(name):
+    """Uninstall a CLI harness by name. Returns (success, message)."""
+    cli = get_cli(name)
+    if cli is None:
+        return False, f"CLI '{name}' not found in registry."
+
+    # The pip package name follows the pattern: cli-anything-<name> with underscores
+    # but we derive it from the install_cmd's subdirectory
+    # The namespace package is cli_anything.<name>, entry point is cli-anything-<name>
+    # pip package name in subdirectory installs is the name from setup.py
+    # We'll uninstall by the entry_point pattern
+    pkg_name = f"cli-anything-{cli['name']}"
+
+    result = subprocess.run(
+        [sys.executable, "-m", "pip", "uninstall", "-y", pkg_name],
+        capture_output=True, text=True
+    )
+
+    if result.returncode == 0:
+        installed = _load_installed()
+        installed.pop(cli["name"], None)
+        _save_installed(installed)
+        return True, f"Uninstalled {cli['display_name']}"
+    else:
+        return False, f"pip uninstall failed:\n{result.stderr}"
+
+
+def get_installed():
+    """Return dict of installed CLIs."""
+    return _load_installed()
+
+
+def update_cli(name):
+    """Update a CLI by reinstalling from the latest source."""
+    cli = get_cli(name, fetch_registry(force_refresh=True))
+    if cli is None:
+        return False, f"CLI '{name}' not found in registry."
+
+    install_cmd = cli["install_cmd"]
+    result = subprocess.run(
+        [sys.executable, "-m", "pip", "install", "--upgrade", "--force-reinstall"]
+        + install_cmd.replace("pip install ", "").split(),
+        capture_output=True, text=True
+    )
+
+    if result.returncode == 0:
+        installed = _load_installed()
+        installed[cli["name"]] = {
+            "version": cli["version"],
+            "entry_point": cli["entry_point"],
+            "install_cmd": install_cmd,
+        }
+        _save_installed(installed)
+        return True, f"Updated {cli['display_name']} to {cli['version']}"
+    else:
+        return False, f"Update failed:\n{result.stderr}"

cli_hub/registry.py

@@ -0,0 +1,72 @@
+"""Fetch and cache the CLI-Anything registry."""
+
+import json
+import os
+import time
+from pathlib import Path
+
+import requests
+
+REGISTRY_URL = "https://hkuds.github.io/CLI-Anything/registry.json"
+CACHE_DIR = Path.home() / ".cli-hub"
+CACHE_FILE = CACHE_DIR / "registry_cache.json"
+CACHE_TTL = 3600  # 1 hour
+
+
+def _ensure_cache_dir():
+    CACHE_DIR.mkdir(parents=True, exist_ok=True)
+
+
+def fetch_registry(force_refresh=False):
+    """Fetch registry.json, using a local cache with TTL."""
+    _ensure_cache_dir()
+
+    if not force_refresh and CACHE_FILE.exists():
+        try:
+            cached = json.loads(CACHE_FILE.read_text())
+            if time.time() - cached.get("_cached_at", 0) < CACHE_TTL:
+                return cached["data"]
+        except (json.JSONDecodeError, KeyError):
+            pass
+
+    resp = requests.get(REGISTRY_URL, timeout=15)
+    resp.raise_for_status()
+    data = resp.json()
+
+    cache_payload = {"_cached_at": time.time(), "data": data}
+    CACHE_FILE.write_text(json.dumps(cache_payload, indent=2))
+
+    return data
+
+
+def get_cli(name, registry=None):
+    """Look up a CLI entry by name (case-insensitive)."""
+    if registry is None:
+        registry = fetch_registry()
+    name_lower = name.lower()
+    for cli in registry["clis"]:
+        if cli["name"].lower() == name_lower:
+            return cli
+    return None
+
+
+def search_clis(query, registry=None):
+    """Search CLIs by name, description, or category."""
+    if registry is None:
+        registry = fetch_registry()
+    query_lower = query.lower()
+    results = []
+    for cli in registry["clis"]:
+        if (query_lower in cli["name"].lower()
+                or query_lower in cli["description"].lower()
+                or query_lower in cli.get("category", "").lower()
+                or query_lower in cli.get("display_name", "").lower()):
+            results.append(cli)
+    return results
+
+
+def list_categories(registry=None):
+    """Return sorted list of unique categories."""
+    if registry is None:
+        registry = fetch_registry()
+    return sorted(set(cli.get("category", "uncategorized") for cli in registry["clis"]))