hypercli-cli 1.0.3__tar.gz → 1.0.5__tar.gz

{hypercli_cli-1.0.3 → hypercli_cli-1.0.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hypercli-cli
-Version: 1.0.3
+Version: 1.0.5
 Summary: CLI for HyperCLI - GPU orchestration and LLM API
 Project-URL: Homepage, https://hypercli.com
 Project-URL: Documentation, https://docs.hypercli.com
@@ -18,6 +18,7 @@ Requires-Dist: websocket-client>=1.6.0
 Provides-Extra: all
 Requires-Dist: argon2-cffi>=25.0.0; extra == 'all'
 Requires-Dist: eth-account>=0.13.0; extra == 'all'
+Requires-Dist: faster-whisper>=1.1.0; extra == 'all'
 Requires-Dist: hypercli-sdk[comfyui]>=1.0.0; extra == 'all'
 Requires-Dist: web3>=7.0.0; extra == 'all'
 Requires-Dist: x402[evm,httpx]>=2.0.0; extra == 'all'
@@ -26,6 +27,8 @@ Requires-Dist: hypercli-sdk[comfyui]>=1.0.0; extra == 'comfyui'
 Provides-Extra: dev
 Requires-Dist: pytest>=8.0.0; extra == 'dev'
 Requires-Dist: ruff>=0.3.0; extra == 'dev'
+Provides-Extra: stt
+Requires-Dist: faster-whisper>=1.1.0; extra == 'stt'
 Provides-Extra: wallet
 Requires-Dist: argon2-cffi>=25.0.0; extra == 'wallet'
 Requires-Dist: eth-account>=0.13.0; extra == 'wallet'

{hypercli_cli-1.0.3 → hypercli_cli-1.0.5}/hypercli_cli/claw.py

@@ -9,6 +9,8 @@ from rich.table import Table
 
 from .onboard import onboard as _onboard_fn
 from .voice import app as voice_app
+from .stt import app as stt_app
+from .embed import app as embed_app
 
 app = typer.Typer(help="HyperClaw inference commands")
 console = Console()
@@ -16,6 +18,8 @@ console = Console()
 # Register subcommands
 app.command("onboard")(_onboard_fn)
 app.add_typer(voice_app, name="voice")
+app.add_typer(stt_app, name="stt")
+app.add_typer(embed_app, name="embed")
 
 # Check if wallet dependencies are available
 try:
@@ -582,7 +586,7 @@ def openclaw_setup(
     # Fetch current model list from LiteLLM via API
     models = fetch_models(api_key)
 
-    # Patch only models.providers.hyperclaw
+    # Patch models.providers.hyperclaw + embedding config
     config.setdefault("models", {}).setdefault("providers", {})
     config["models"]["providers"]["hyperclaw"] = {
         "baseUrl": "https://api.hyperclaw.app/v1",
@@ -591,9 +595,20 @@ def openclaw_setup(
         "models": models,
     }
 
+    # Always set embedding provider (reuses same API key)
+    config.setdefault("agents", {}).setdefault("defaults", {})
+    config["agents"]["defaults"]["memorySearch"] = {
+        "provider": "openai",
+        "model": "qwen3-embedding-4b",
+        "remote": {
+            "baseUrl": "https://api.hyperclaw.app/v1/",
+            "apiKey": api_key,
+        }
+    }
+
     # Optionally set default model
     if default:
-        config.setdefault("agents", {}).setdefault("defaults", {}).setdefault("model", {})
+        config["agents"]["defaults"].setdefault("model", {})
         config["agents"]["defaults"]["model"]["primary"] = f"hyperclaw/{models[0]['id']}"
 
     # Write back
@@ -630,14 +645,14 @@ def _resolve_api_key(key: str | None) -> str:
     raise typer.Exit(1)
 
 
-def _config_openclaw(api_key: str, models: list[dict]) -> dict:
-    """OpenClaw openclaw.json provider snippet."""
+def _config_openclaw(api_key: str, models: list[dict], api_base: str = PROD_API_BASE) -> dict:
+    """OpenClaw openclaw.json provider snippet (LLM + embeddings)."""
     return {
         "models": {
             "mode": "merge",
             "providers": {
                 "hyperclaw": {
-                    "baseUrl": "https://api.hyperclaw.app/v1",
+                    "baseUrl": f"{api_base}/v1",
                     "apiKey": api_key,
                     "api": "openai-completions",
                     "models": models,
@@ -648,6 +663,14 @@ def _config_openclaw(api_key: str, models: list[dict]) -> dict:
             "defaults": {
                 "models": {
                     **{f"hyperclaw/{m['id']}": {"alias": m['id'].split('-')[0]} for m in models}
+                },
+                "memorySearch": {
+                    "provider": "openai",
+                    "model": "qwen3-embedding-4b",
+                    "remote": {
+                        "baseUrl": f"{api_base}/v1/",
+                        "apiKey": api_key,
+                    }
                 }
             }
         }
@@ -725,7 +748,7 @@ def config_cmd(
 
     for fmt in formats:
         if fmt == "openclaw":
-            snippet = _config_openclaw(api_key, models)
+            snippet = _config_openclaw(api_key, models, api_base)
             _show_snippet("OpenClaw", "~/.openclaw/openclaw.json", snippet, apply, OPENCLAW_CONFIG_PATH)
         elif fmt == "opencode":
             snippet = _config_opencode(api_key, models)

hypercli_cli-1.0.5/hypercli_cli/embed.py

@@ -0,0 +1,142 @@
+"""HyperClaw Embed — text embeddings via HyperClaw API."""
+import json
+from pathlib import Path
+
+import httpx
+import typer
+from rich.console import Console
+
+app = typer.Typer(help="Text embeddings via HyperClaw API (qwen3-embedding-4b)")
+console = Console()
+
+HYPERCLI_DIR = Path.home() / ".hypercli"
+CLAW_KEY_PATH = HYPERCLI_DIR / "claw-key.json"
+PROD_API_BASE = "https://api.hyperclaw.app"
+DEV_API_BASE = "https://api.dev.hyperclaw.app"
+
+
+def _get_api_key(key: str | None) -> str:
+    if key:
+        return key
+    if CLAW_KEY_PATH.exists():
+        with open(CLAW_KEY_PATH) as f:
+            k = json.load(f).get("key", "")
+        if k:
+            return k
+    console.print("[red]❌ No API key found.[/red]")
+    console.print("Pass [bold]--key sk-...[/bold] or run [bold]hyper claw subscribe[/bold]")
+    raise typer.Exit(1)
+
+
+@app.command("text")
+def embed_text(
+    text: str = typer.Argument(..., help="Text to embed"),
+    model: str = typer.Option("qwen3-embedding-4b", "--model", "-m", help="Embedding model"),
+    key: str = typer.Option(None, "--key", "-k", help="API key (sk-...)"),
+    dev: bool = typer.Option(False, "--dev", help="Use dev API"),
+    json_output: bool = typer.Option(False, "--json", help="Output full JSON response"),
+    output: Path = typer.Option(None, "--output", "-o", help="Write embeddings to file"),
+):
+    """Generate embeddings for text.
+
+    Examples:
+      hyper claw embed text "Hello world"
+      hyper claw embed text "Test" --json
+      hyper claw embed text "Document chunk" -o embedding.json
+    """
+    api_key = _get_api_key(key)
+    api_base = DEV_API_BASE if dev else PROD_API_BASE
+    url = f"{api_base}/v1/embeddings"
+
+    try:
+        resp = httpx.post(
+            url,
+            json={"model": model, "input": text},
+            headers={"Authorization": f"Bearer {api_key}"},
+            timeout=30.0,
+        )
+        resp.raise_for_status()
+        data = resp.json()
+    except httpx.HTTPError as e:
+        console.print(f"[red]❌ Embedding request failed: {e}[/red]")
+        raise typer.Exit(1)
+
+    embedding = data["data"][0]["embedding"]
+    dims = len(embedding)
+    usage = data.get("usage", {})
+    tokens = usage.get("total_tokens", 0)
+
+    if json_output:
+        result = json.dumps(data, indent=2)
+        if output:
+            output.write_text(result)
+            console.print(f"[green]✅ Written to {output} ({dims} dimensions, {tokens} tokens)[/green]")
+        else:
+            print(result)
+    else:
+        console.print(f"[green]✅ Embedded ({dims} dimensions, {tokens} tokens)[/green]")
+        console.print(f"[dim]Model: {data.get('model', model)}[/dim]")
+        console.print(f"[dim]First 5: {embedding[:5]}[/dim]")
+        if output:
+            output.write_text(json.dumps(embedding))
+            console.print(f"[green]Saved to {output}[/green]")
+
+
+@app.command("test")
+def embed_test(
+    key: str = typer.Option(None, "--key", "-k", help="API key (sk-...)"),
+    dev: bool = typer.Option(False, "--dev", help="Use dev API"),
+):
+    """Quick test to verify embedding endpoint works.
+
+    Examples:
+      hyper claw embed test
+      hyper claw embed test --dev
+    """
+    api_key = _get_api_key(key)
+    api_base = DEV_API_BASE if dev else PROD_API_BASE
+    url = f"{api_base}/v1/embeddings"
+
+    test_texts = [
+        "The quick brown fox jumps over the lazy dog.",
+        "GPU orchestration and cloud computing infrastructure.",
+    ]
+
+    console.print(f"[bold]Testing embedding endpoint: {url}[/bold]\n")
+
+    try:
+        resp = httpx.post(
+            url,
+            json={"model": "qwen3-embedding-4b", "input": test_texts},
+            headers={"Authorization": f"Bearer {api_key}"},
+            timeout=30.0,
+        )
+        resp.raise_for_status()
+        data = resp.json()
+    except httpx.HTTPError as e:
+        console.print(f"[red]❌ FAIL: {e}[/red]")
+        raise typer.Exit(1)
+
+    embeddings = data.get("data", [])
+    if len(embeddings) != 2:
+        console.print(f"[red]❌ Expected 2 embeddings, got {len(embeddings)}[/red]")
+        raise typer.Exit(1)
+
+    dims = len(embeddings[0]["embedding"])
+    usage = data.get("usage", {})
+
+    # Compute cosine similarity
+    import math
+    v1 = embeddings[0]["embedding"]
+    v2 = embeddings[1]["embedding"]
+    dot = sum(a * b for a, b in zip(v1, v2))
+    mag1 = math.sqrt(sum(a * a for a in v1))
+    mag2 = math.sqrt(sum(b * b for b in v2))
+    cosine_sim = dot / (mag1 * mag2) if mag1 and mag2 else 0
+
+    console.print(f"[green]✅ PASS[/green]")
+    console.print(f"  Model: {data.get('model', 'qwen3-embedding-4b')}")
+    console.print(f"  Dimensions: {dims}")
+    console.print(f"  Tokens: {usage.get('total_tokens', '?')}")
+    console.print(f"  Cosine similarity: {cosine_sim:.4f}")
+    console.print(f"  (Two unrelated sentences should be < 0.9)")

hypercli_cli-1.0.5/hypercli_cli/stt.py

@@ -0,0 +1,105 @@
+"""HyperClaw STT — local speech-to-text via faster-whisper."""
+import sys
+from pathlib import Path
+
+import typer
+from rich.console import Console
+
+app = typer.Typer(help="Speech-to-text via faster-whisper (local, no API key)")
+console = Console()
+
+# Lazy import to avoid crashing when faster-whisper isn't installed
+_model_cache = {}
+
+
+def _get_model(model_size: str, device: str, compute_type: str):
+    """Get or create a cached whisper model."""
+    key = (model_size, device, compute_type)
+    if key not in _model_cache:
+        try:
+            from faster_whisper import WhisperModel
+        except ImportError:
+            console.print("[red]❌ faster-whisper not installed.[/red]")
+            console.print("Install with: [bold]pip install 'hypercli-cli[stt]'[/bold]")
+            console.print("Or: [bold]pip install 'hypercli-cli[all]'[/bold]")
+            raise typer.Exit(1)
+        _model_cache[key] = WhisperModel(model_size, device=device, compute_type=compute_type)
+    return _model_cache[key]
+
+
+@app.command("transcribe")
+def transcribe(
+    audio_file: Path = typer.Argument(..., help="Audio file to transcribe (wav, mp3, ogg, m4a, etc.)"),
+    model: str = typer.Option("turbo", "--model", "-m", help="Whisper model: tiny, base, small, medium, large-v3, turbo"),
+    language: str = typer.Option(None, "--language", "-l", help="Language code (e.g. en, de, fr). Auto-detect if omitted."),
+    device: str = typer.Option("auto", "--device", "-d", help="Device: auto, cpu, cuda"),
+    compute_type: str = typer.Option("auto", "--compute", help="Compute type: auto, int8, float16, float32"),
+    json_output: bool = typer.Option(False, "--json", help="Output as JSON with timestamps"),
+    output: Path = typer.Option(None, "--output", "-o", help="Write transcript to file"),
+):
+    """Transcribe audio to text using faster-whisper (runs locally).
+
+    Examples:
+      hyper claw stt transcribe voice.ogg
+      hyper claw stt transcribe meeting.mp3 --model large-v3 --language en
+      hyper claw stt transcribe audio.wav --json -o transcript.json
+    """
+    if not audio_file.exists():
+        console.print(f"[red]❌ File not found: {audio_file}[/red]")
+        raise typer.Exit(1)
+
+    # Auto-select compute type based on device
+    if compute_type == "auto":
+        compute_type = "int8" if device == "cpu" else "float16"
+    if device == "auto":
+        try:
+            import torch
+            device = "cuda" if torch.cuda.is_available() else "cpu"
+        except ImportError:
+            device = "cpu"
+        if device == "cpu" and compute_type == "float16":
+            compute_type = "int8"
+
+    console.print(f"[dim]Model: {model} | Device: {device} | Compute: {compute_type}[/dim]")
+    console.print(f"[dim]File: {audio_file} ({audio_file.stat().st_size / 1024:.1f} KB)[/dim]")
+
+    whisper_model = _get_model(model, device, compute_type)
+
+    kwargs = {}
+    if language:
+        kwargs["language"] = language
+
+    segments, info = whisper_model.transcribe(str(audio_file), **kwargs)
+
+    if not language:
+        console.print(f"[dim]Detected language: {info.language} (p={info.language_probability:.2f})[/dim]")
+
+    if json_output:
+        import json
+        results = []
+        for seg in segments:
+            results.append({
+                "start": round(seg.start, 3),
+                "end": round(seg.end, 3),
+                "text": seg.text.strip(),
+            })
+        output_text = json.dumps({
+            "language": info.language,
+            "language_probability": round(info.language_probability, 3),
+            "duration": round(info.duration, 3),
+            "segments": results,
+            "text": " ".join(r["text"] for r in results),
+        }, indent=2, ensure_ascii=False)
+    else:
+        parts = []
+        for seg in segments:
+            parts.append(seg.text.strip())
+        output_text = " ".join(parts)
+
+    if output:
+        output.parent.mkdir(parents=True, exist_ok=True)
+        output.write_text(output_text)
+        console.print(f"[green]✅ Written to {output}[/green]")
+    else:
+        # Print to stdout (useful for piping)
+        print(output_text)

{hypercli_cli-1.0.3 → hypercli_cli-1.0.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "hypercli-cli"
-version = "1.0.3"
+version = "1.0.5"
 description = "CLI for HyperCLI - GPU orchestration and LLM API"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -33,12 +33,16 @@ wallet = [
     "argon2-cffi>=25.0.0",
     "qrcode[pil]>=7.4.0",
 ]
+stt = [
+    "faster-whisper>=1.1.0",
+]
 all = [
     "hypercli-sdk[comfyui]>=1.0.0",
     "x402[httpx,evm]>=2.0.0",
     "eth-account>=0.13.0",
     "web3>=7.0.0",
     "argon2-cffi>=25.0.0",
+    "faster-whisper>=1.1.0",
 ]
 dev = [
     "pytest>=8.0.0",