vibe-cli 0.1.0__tar.gz

vibe_cli-0.1.0/PKG-INFO

@@ -0,0 +1,89 @@
+Metadata-Version: 2.2
+Name: vibe-cli
+Version: 0.1.0
+Summary: VIBE Airforce CLI — Web3 trading and data at your fingertips
+License: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: typer>=0.12.0
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: pydantic>=2.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: ruff>=0.4.0; extra == "dev"
+
+# vibe-cli
+
+Web3 trading and data at your fingertips.
+
+## Install
+
+```bash
+# pip
+pip install vibe-cli
+
+# pipx (isolated)
+pipx install vibe-cli
+
+# curl | sh
+curl -fsSL https://api.vibe.airforce/api/cli/install.sh | sh
+```
+
+## Quick Start
+
+```bash
+vibe sync                    # Fetch operations manifest (works without API key)
+vibe list-operations         # List all commands
+vibe swap-quote --from-token So11111111111111111111111111111111111111112 \
+                 --to-token EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v \
+                 --amount 1000000
+vibe evm-swap-quote --network base --from-asset eth --to-asset usdc --amount 0.1
+```
+
+## Auth
+
+No API key required to try — 30 free credits per day.
+
+```bash
+vibe auth                    # Paste your API key interactively
+# Or set environment variable
+export VIBE_API_KEY=pk_xxx:sk_xxx
+```
+
+Get your API key at [vibe.airforce/settings/api-keys](https://www.vibe.airforce/settings/api-keys)
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `vibe sync` | Fetch operations manifest |
+| `vibe list-operations` | List available commands |
+| `vibe auth` | Authenticate with API key |
+| `vibe logout` | Remove saved credentials |
+| `vibe swap-quote` | Solana swap quote |
+| `vibe swap` | Execute Solana swap |
+| `vibe evm-swap-quote` | Base/Ethereum swap quote |
+| `vibe evm-swap` | Execute Base/Ethereum swap |
+| `vibe defi-discover` | Discover DeFi protocols |
+| `vibe defi-quote` | Get DeFi position quote |
+| `vibe defi-deposit` | Execute DeFi deposit |
+| `vibe bags-launch-token` | Launch token on bags.fm |
+| `vibe bags-claim-fees` | Claim bags.fm fees |
+| `vibe bags-positions` | View bags.fm positions |
+| `vibe data-provider` | Query external data providers |
+| `vibe feedback` | Submit feedback |
+| `vibe version` | Show CLI version |
+
+## Output Formats
+
+```bash
+vibe swap-quote -o table ...   # Human-readable (default)
+vibe swap-quote -o json ...    # Structured JSON
+vibe swap-quote -o json -f body.data ...  # Extract nested field
+vibe swap-quote -o raw ...     # Unformatted JSON
+```
+
+## License
+
+MIT

vibe_cli-0.1.0/README.md

@@ -0,0 +1,74 @@
+# vibe-cli
+
+Web3 trading and data at your fingertips.
+
+## Install
+
+```bash
+# pip
+pip install vibe-cli
+
+# pipx (isolated)
+pipx install vibe-cli
+
+# curl | sh
+curl -fsSL https://api.vibe.airforce/api/cli/install.sh | sh
+```
+
+## Quick Start
+
+```bash
+vibe sync                    # Fetch operations manifest (works without API key)
+vibe list-operations         # List all commands
+vibe swap-quote --from-token So11111111111111111111111111111111111111112 \
+                 --to-token EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v \
+                 --amount 1000000
+vibe evm-swap-quote --network base --from-asset eth --to-asset usdc --amount 0.1
+```
+
+## Auth
+
+No API key required to try — 30 free credits per day.
+
+```bash
+vibe auth                    # Paste your API key interactively
+# Or set environment variable
+export VIBE_API_KEY=pk_xxx:sk_xxx
+```
+
+Get your API key at [vibe.airforce/settings/api-keys](https://www.vibe.airforce/settings/api-keys)
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `vibe sync` | Fetch operations manifest |
+| `vibe list-operations` | List available commands |
+| `vibe auth` | Authenticate with API key |
+| `vibe logout` | Remove saved credentials |
+| `vibe swap-quote` | Solana swap quote |
+| `vibe swap` | Execute Solana swap |
+| `vibe evm-swap-quote` | Base/Ethereum swap quote |
+| `vibe evm-swap` | Execute Base/Ethereum swap |
+| `vibe defi-discover` | Discover DeFi protocols |
+| `vibe defi-quote` | Get DeFi position quote |
+| `vibe defi-deposit` | Execute DeFi deposit |
+| `vibe bags-launch-token` | Launch token on bags.fm |
+| `vibe bags-claim-fees` | Claim bags.fm fees |
+| `vibe bags-positions` | View bags.fm positions |
+| `vibe data-provider` | Query external data providers |
+| `vibe feedback` | Submit feedback |
+| `vibe version` | Show CLI version |
+
+## Output Formats
+
+```bash
+vibe swap-quote -o table ...   # Human-readable (default)
+vibe swap-quote -o json ...    # Structured JSON
+vibe swap-quote -o json -f body.data ...  # Extract nested field
+vibe swap-quote -o raw ...     # Unformatted JSON
+```
+
+## License
+
+MIT

vibe_cli-0.1.0/pyproject.toml

@@ -0,0 +1,29 @@
+[build-system]
+requires = ["setuptools>=68.0,<77.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "vibe-cli"
+version = "0.1.0"
+description = "VIBE Airforce CLI — Web3 trading and data at your fingertips"
+readme = "README.md"
+requires-python = ">=3.10"
+license = {text = "MIT"}
+dependencies = [
+    "typer>=0.12.0",
+    "httpx>=0.27.0",
+    "rich>=13.0.0",
+    "pydantic>=2.0.0",
+]
+
+[project.scripts]
+vibe = "vibe_cli.main:app"
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0",
+    "ruff>=0.4.0",
+]
+
+[tool.setuptools]
+license-files = []

vibe_cli-0.1.0/setup.cfg

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

vibe_cli-0.1.0/vibe_cli/__init__.py

@@ -0,0 +1,3 @@
+"""VIBE Airforce CLI — Web3 trading and data at your fingertips."""
+
+__version__ = "0.1.0"

vibe_cli-0.1.0/vibe_cli/auth.py

@@ -0,0 +1,108 @@
+"""Authentication flow for the VIBE CLI."""
+
+from typing import Optional
+
+from rich.console import Console
+
+from vibe_cli.config import load_config, save_config, get_api_key, get_trial_token, save_trial_token
+
+console = Console()
+
+
+def login(interactive: bool = True) -> Optional[str]:
+    """
+    Authenticate with the VIBE API.
+
+    If interactive, prompt the user to paste their API key.
+    Otherwise, check config and env vars.
+    """
+    # Check existing key
+    existing = get_api_key()
+    if existing and not interactive:
+        return existing
+
+    if interactive:
+        console.print("\n[bold]VIBE Airforce Authentication[/bold]")
+        console.print("Get your API key at: [link]https://www.vibe.airforce/settings/api-keys[/link]")
+        console.print()
+        console.print("Your API key looks like: [dim]pk_xxxxxxxx:sk_xxxxxxxxxxxxxxxx[/dim]")
+        console.print()
+
+        api_key = console.input("[bold]Paste your API key:[/bold] ").strip()
+
+        if not api_key or ":" not in api_key:
+            console.print("[red]Invalid API key format. Expected: pk_xxx:sk_xxx[/red]")
+            return None
+
+        # Save to config
+        config = load_config()
+        config["api_key"] = api_key
+        save_config(config)
+
+        console.print("[green]API key saved![/green] You can now use all VIBE commands.")
+        return api_key
+
+    return None
+
+
+def logout() -> None:
+    """Remove saved API key and trial token."""
+    config = load_config()
+    removed = False
+    if "api_key" in config:
+        del config["api_key"]
+        removed = True
+    if "trial_token" in config:
+        del config["trial_token"]
+        removed = True
+    save_config(config)
+    if removed:
+        console.print("[green]Logged out successfully.[/green]")
+    else:
+        console.print("[dim]No API key found in config.[/dim]")
+
+
+def _ensure_trial_token() -> Optional[str]:
+    """Get a trial token if no API key is configured. Cache it in config."""
+    # Don't request trial if user has an API key
+    if get_api_key():
+        return None
+
+    # Check for cached trial token
+    cached = get_trial_token()
+    if cached:
+        return cached
+
+    # Request a new trial token
+    try:
+        import httpx
+        from vibe_cli.config import get_base_url
+        base_url = get_base_url().rstrip("/")
+        resp = httpx.post(f"{base_url}/api/vibe-tools/trial-auth", timeout=10.0)
+        if resp.status_code == 200:
+            data = resp.json().get("data", {})
+            token = data.get("token")
+            if token:
+                save_trial_token(token)
+                return token
+    except Exception:
+        pass
+
+    return None
+
+
+def get_auth_header() -> dict:
+    """Get Authorization header for API requests.
+
+    Uses API key if configured, otherwise auto-obtains a trial token.
+    """
+    api_key = get_api_key()
+    if api_key:
+        return {"Authorization": f"Bearer {api_key}"}
+
+    # Auto-trial: get a free trial token so unauthenticated users can explore
+    trial = _ensure_trial_token()
+    if trial:
+        return {"Authorization": f"Bearer {trial}"}
+
+    return {}

vibe_cli-0.1.0/vibe_cli/client.py

@@ -0,0 +1,133 @@
+"""HTTP client for the VIBE Tools Gateway."""
+
+from typing import Any, Optional
+
+import httpx
+from rich.console import Console
+
+from vibe_cli.config import get_base_url
+from vibe_cli.auth import get_auth_header
+
+console = Console()
+
+
+class VibeClient:
+    """Thin HTTP client for /vibe-tools/* routes."""
+
+    def __init__(self, base_url: Optional[str] = None):
+        self.base_url = (base_url or get_base_url()).rstrip("/")
+
+    async def request(
+        self,
+        method: str,
+        path: str,
+        json_body: Optional[dict] = None,
+        params: Optional[dict] = None,
+    ) -> dict:
+        """Make an authenticated request to the vibe-tools gateway."""
+        url = f"{self.base_url}/api{path}"
+        headers = get_auth_header()
+        headers["Content-Type"] = "application/json"
+
+        async with httpx.AsyncClient(timeout=30.0) as client:
+            response = await client.request(
+                method=method,
+                url=url,
+                headers=headers,
+                json=json_body,
+                params=params,
+            )
+
+        return self._handle_response(response)
+
+    def request_sync(
+        self,
+        method: str,
+        path: str,
+        json_body: Optional[dict] = None,
+        params: Optional[dict] = None,
+    ) -> dict:
+        """Synchronous version of request."""
+        url = f"{self.base_url}/api{path}"
+        headers = get_auth_header()
+        headers["Content-Type"] = "application/json"
+
+        with httpx.Client(timeout=30.0) as client:
+            response = client.request(
+                method=method,
+                url=url,
+                headers=headers,
+                json=json_body,
+                params=params,
+            )
+
+        return self._handle_response(response)
+
+    @staticmethod
+    def _handle_response(response: httpx.Response) -> dict:
+        """Parse response and handle errors."""
+        try:
+            body = response.json()
+        except Exception:
+            return {"error": {"code": "PARSE_ERROR", "message": response.text}}
+
+        if response.status_code >= 400:
+            error = body.get("error", {})
+            error.setdefault("code", "UNKNOWN")
+            error.setdefault("message", f"HTTP {response.status_code}")
+            return {"error": error}
+
+        return body
+
+    # Convenience methods
+
+    def get_operations(self) -> dict:
+        return self.request_sync("GET", "/vibe-tools/operations")
+
+    def trial_auth(self) -> dict:
+        return self.request_sync("POST", "/vibe-tools/trial-auth")
+
+    def data_provider(self, service_name: str, route: str, payload: Optional[dict] = None) -> dict:
+        return self.request_sync("POST", "/vibe-tools/data-provider", {
+            "service_name": service_name,
+            "route": route,
+            "payload": payload,
+        })
+
+    def swap_quote(self, input_mint: str, output_mint: str, amount: int, **kwargs) -> dict:
+        body = {"input_mint": input_mint, "output_mint": output_mint, "amount": amount, **kwargs}
+        return self.request_sync("POST", "/vibe-tools/swap-quote", body)
+
+    def swap(self, input_mint: str, output_mint: str, amount: int, **kwargs) -> dict:
+        body = {"input_mint": input_mint, "output_mint": output_mint, "amount": amount, **kwargs}
+        return self.request_sync("POST", "/vibe-tools/swap", body)
+
+    def evm_swap_quote(self, network: str, from_asset: str, to_asset: str, amount: str, **kwargs) -> dict:
+        body = {"network": network, "from_asset": from_asset, "to_asset": to_asset, "amount": amount, **kwargs}
+        return self.request_sync("POST", "/vibe-tools/evm/swap-quote", body)
+
+    def evm_swap(self, network: str, from_asset: str, to_asset: str, amount: str, **kwargs) -> dict:
+        body = {"network": network, "from_asset": from_asset, "to_asset": to_asset, "amount": amount, **kwargs}
+        return self.request_sync("POST", "/vibe-tools/evm/swap", body)
+
+    def defi_discover(self, protocols: Optional[list] = None) -> dict:
+        body = {"protocols": protocols} if protocols else {}
+        return self.request_sync("POST", "/vibe-tools/defi/discover", body)
+
+    def defi_quote(self, action: str, token: str, amount: str, protocol: str = "marinade", **kwargs) -> dict:
+        body = {"action": action, "token": token, "amount": amount, "protocol": protocol, **kwargs}
+        return self.request_sync("POST", "/vibe-tools/defi/quote", body)
+
+    def defi_deposit(self, action: str, token: str, amount: str, protocol: str = "marinade", **kwargs) -> dict:
+        body = {"action": action, "token": token, "amount": amount, "protocol": protocol, **kwargs}
+        return self.request_sync("POST", "/vibe-tools/defi/deposit", body)
+
+    def bags_launch_token(self, name: str, symbol: str, description: str, image_url: str, **kwargs) -> dict:
+        body = {"name": name, "symbol": symbol, "description": description, "image_url": image_url, **kwargs}
+        return self.request_sync("POST", "/vibe-tools/bags/launch-token", body)
+
+    def bags_claim_fees(self, token_mint: str) -> dict:
+        return self.request_sync("POST", "/vibe-tools/bags/claim-fees", {"token_mint": token_mint})
+
+    def bags_positions(self) -> dict:
+        return self.request_sync("GET", "/vibe-tools/bags/positions")

vibe_cli-0.1.0/vibe_cli/config.py

@@ -0,0 +1,77 @@
+"""Configuration management for the VIBE CLI."""
+
+import json
+import os
+from pathlib import Path
+from typing import Optional
+
+
+CONFIG_DIR = Path.home() / ".config" / "vibe"
+CONFIG_FILE = CONFIG_DIR / "config.json"
+MANIFEST_CACHE_FILE = CONFIG_DIR / "manifest.json"
+
+
+def _ensure_config_dir() -> None:
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+
+
+def load_config() -> dict:
+    """Load CLI config from disk."""
+    if CONFIG_FILE.exists():
+        try:
+            return json.loads(CONFIG_FILE.read_text())
+        except (json.JSONDecodeError, OSError):
+            return {}
+    return {}
+
+
+def save_config(config: dict) -> None:
+    """Save CLI config to disk."""
+    _ensure_config_dir()
+    CONFIG_FILE.write_text(json.dumps(config, indent=2))
+
+
+def get_api_key() -> Optional[str]:
+    """Get API key from env var, config, or return None."""
+    # 1. Environment variable
+    env_key = os.environ.get("VIBE_API_KEY")
+    if env_key:
+        return env_key
+
+    # 2. Config file
+    config = load_config()
+    return config.get("api_key")
+
+
+def get_trial_token() -> Optional[str]:
+    """Get cached trial token from config."""
+    config = load_config()
+    return config.get("trial_token")
+
+
+def save_trial_token(token: str) -> None:
+    """Save trial token to config."""
+    config = load_config()
+    config["trial_token"] = token
+    save_config(config)
+
+
+def get_base_url() -> str:
+    """Get the VIBE API base URL."""
+    return os.environ.get("VIBE_API_URL", "https://api.vibe.airforce")
+
+
+def get_manifest_cache() -> Optional[dict]:
+    """Load cached operations manifest."""
+    if MANIFEST_CACHE_FILE.exists():
+        try:
+            return json.loads(MANIFEST_CACHE_FILE.read_text())
+        except (json.JSONDecodeError, OSError):
+            return None
+    return None
+
+
+def save_manifest_cache(manifest: dict) -> None:
+    """Cache the operations manifest."""
+    _ensure_config_dir()
+    MANIFEST_CACHE_FILE.write_text(json.dumps(manifest, indent=2))

vibe_cli-0.1.0/vibe_cli/main.py

@@ -0,0 +1,283 @@
+"""VIBE Airforce CLI — Web3 trading and data at your fingertips.
+
+Usage:
+    vibe sync                          Fetch operations manifest
+    vibe list-operations               List available commands
+    vibe auth                          Authenticate with API key
+    vibe <command> [options]           Execute a vibe-tools command
+
+Examples:
+    vibe sync
+    vibe list-operations | grep swap
+    vibe swap-quote --from-token So11111111111111111111111111111111111111112 \
+                     --to-token EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v \
+                     --amount 1000000
+    vibe evm-swap-quote --network base --from-asset eth --to-asset usdc --amount 0.1
+"""
+
+import json as _json
+from typing import Optional
+
+import typer
+from rich.console import Console
+
+from vibe_cli import __version__
+from vibe_cli.auth import login, logout as auth_logout
+from vibe_cli.config import get_api_key
+from vibe_cli.operations import sync_manifest, list_operations, execute_operation
+from vibe_cli.output import format_output, print_error
+
+console = Console()
+
+app = typer.Typer(
+    name="vibe",
+    help="VIBE Airforce — Web3 trading and data at your fingertips",
+    no_args_is_help=True,
+    add_completion=False,
+)
+
+
+# ---------------------------------------------------------------------------
+# Core commands
+# ---------------------------------------------------------------------------
+
+@app.command()
+def sync():
+    """Fetch the latest operations manifest from the VIBE gateway."""
+    console.print("[bold]Syncing operations manifest...[/bold]")
+    manifest = sync_manifest()
+    console.print(f"[green]Synced {len(manifest)} operations.[/green]")
+    console.print("Run [bold]vibe list-operations[/bold] to see available commands.")
+
+
+@app.command(name="list-operations")
+def list_ops(
+    filter: Optional[str] = typer.Argument(None, help="Filter operations by keyword"),
+):
+    """List all available vibe-tools operations."""
+    list_operations(filter)
+
+
+@app.command()
+def auth():
+    """Authenticate with your VIBE API key."""
+    login(interactive=True)
+
+
+@app.command()
+def logout():
+    """Remove saved API key."""
+    auth_logout()
+
+
+@app.command()
+def install():
+    """Update the VIBE CLI to the latest version."""
+    console.print("[bold]Checking for updates...[/bold]")
+    import subprocess
+    subprocess.run(["pip", "install", "--upgrade", "vibe-cli"])
+
+
+@app.command()
+def feedback(
+    message: str = typer.Argument(..., help="Your feedback message"),
+):
+    """Submit feedback about the VIBE CLI."""
+    console.print(f"[green]Thank you for your feedback![/green]")
+    console.print(f"[dim]Message: {message}[/dim]")
+
+
+@app.command()
+def version():
+    """Show the VIBE CLI version."""
+    console.print(f"vibe CLI v{__version__}")
+
+
+# ---------------------------------------------------------------------------
+# Route commands — explicit functions for each vibe-tools operation
+# ---------------------------------------------------------------------------
+
+def _output_opts():
+    """Common output options shared by all route commands."""
+    return {
+        "output": typer.Option("table", "-o", "--output", help="Output format: table, json, raw"),
+        "field": typer.Option(None, "-f", "--field", help="Extract nested field (dot-path e.g. 'body.data')"),
+    }
+
+
+# --- Data Provider ---
+
+@app.command(name="data-provider")
+def data_provider(
+    service: str = typer.Option(..., "--service", help="Provider name (e.g. 'nansen', 'twitter')"),
+    route: str = typer.Option(..., "--route", help="Endpoint key (e.g. 'smart_money_netflows')"),
+    payload: Optional[str] = typer.Option(None, "--payload", help="JSON payload for the provider"),
+    output: str = typer.Option("table", "-o", "--output", help="Output format: table, json, raw"),
+    field: Optional[str] = typer.Option(None, "-f", "--field", help="Extract nested field"),
+):
+    """Query external data providers (Nansen, Twitter, etc.)."""
+    params: dict = {"service_name": service, "route": route}
+    if payload:
+        try:
+            params["payload"] = _json.loads(payload)
+        except _json.JSONDecodeError:
+            console.print("[red]Invalid JSON payload[/red]")
+            raise typer.Exit(1)
+    execute_operation("POST /vibe-tools/data-provider", params, output, field)
+
+
+# --- Solana Swap ---
+
+@app.command(name="swap-quote")
+def swap_quote(
+    from_token: str = typer.Option(..., "--from-token", help="Input token mint address"),
+    to_token: str = typer.Option(..., "--to-token", help="Output token mint address"),
+    amount: int = typer.Option(..., "--amount", help="Amount in lamports"),
+    slippage_bps: Optional[int] = typer.Option(None, "--slippage-bps", help="Slippage in basis points"),
+    output: str = typer.Option("table", "-o", "--output", help="Output format: table, json, raw"),
+    field: Optional[str] = typer.Option(None, "-f", "--field", help="Extract nested field"),
+):
+    """Get Solana swap quote (Jupiter, Meteora)."""
+    params: dict = {"input_mint": from_token, "output_mint": to_token, "amount": amount}
+    if slippage_bps is not None:
+        params["slippage_bps"] = slippage_bps
+    execute_operation("POST /vibe-tools/swap-quote", params, output, field)
+
+
+@app.command(name="swap")
+def swap(
+    from_token: str = typer.Option(..., "--from-token", help="Input token mint address"),
+    to_token: str = typer.Option(..., "--to-token", help="Output token mint address"),
+    amount: int = typer.Option(..., "--amount", help="Amount in lamports"),
+    slippage_bps: Optional[int] = typer.Option(None, "--slippage-bps", help="Slippage in basis points"),
+    output: str = typer.Option("table", "-o", "--output", help="Output format: table, json, raw"),
+    field: Optional[str] = typer.Option(None, "-f", "--field", help="Extract nested field"),
+):
+    """Execute Solana swap (returns unsigned transaction)."""
+    params: dict = {"input_mint": from_token, "output_mint": to_token, "amount": amount}
+    if slippage_bps is not None:
+        params["slippage_bps"] = slippage_bps
+    execute_operation("POST /vibe-tools/swap", params, output, field)
+
+
+# --- EVM Swap ---
+
+@app.command(name="evm-swap-quote")
+def evm_swap_quote(
+    network: str = typer.Option("base", "--network", help="EVM network: 'base' or 'ethereum'"),
+    from_asset: str = typer.Option(..., "--from-asset", help="Source asset (e.g. 'eth', 'usdc')"),
+    to_asset: str = typer.Option(..., "--to-asset", help="Destination asset"),
+    amount: str = typer.Option(..., "--amount", help="Amount in human-readable units (e.g. '0.1')"),
+    slippage_pct: Optional[float] = typer.Option(None, "--slippage-pct", help="Max slippage percentage"),
+    output: str = typer.Option("table", "-o", "--output", help="Output format: table, json, raw"),
+    field: Optional[str] = typer.Option(None, "-f", "--field", help="Extract nested field"),
+):
+    """Get Base/Ethereum swap quote (0x aggregator)."""
+    params: dict = {"network": network, "from_asset": from_asset, "to_asset": to_asset, "amount": amount}
+    if slippage_pct is not None:
+        params["slippage_pct"] = slippage_pct
+    execute_operation("POST /vibe-tools/evm/swap-quote", params, output, field)
+
+
+@app.command(name="evm-swap")
+def evm_swap(
+    network: str = typer.Option("base", "--network", help="EVM network: 'base' or 'ethereum'"),
+    from_asset: str = typer.Option(..., "--from-asset", help="Source asset"),
+    to_asset: str = typer.Option(..., "--to-asset", help="Destination asset"),
+    amount: str = typer.Option(..., "--amount", help="Amount in human-readable units"),
+    slippage_pct: Optional[float] = typer.Option(None, "--slippage-pct", help="Max slippage percentage"),
+    output: str = typer.Option("table", "-o", "--output", help="Output format: table, json, raw"),
+    field: Optional[str] = typer.Option(None, "-f", "--field", help="Extract nested field"),
+):
+    """Execute Base/Ethereum swap (CDP managed wallet)."""
+    params: dict = {"network": network, "from_asset": from_asset, "to_asset": to_asset, "amount": amount}
+    if slippage_pct is not None:
+        params["slippage_pct"] = slippage_pct
+    execute_operation("POST /vibe-tools/evm/swap", params, output, field)
+
+
+# --- DeFi ---
+
+@app.command(name="defi-discover")
+def defi_discover(
+    protocols: Optional[str] = typer.Option(None, "--protocols", help="Comma-separated protocol filter"),
+    output: str = typer.Option("table", "-o", "--output", help="Output format: table, json, raw"),
+    field: Optional[str] = typer.Option(None, "-f", "--field", help="Extract nested field"),
+):
+    """Discover available DeFi protocols and positions."""
+    params: dict = {}
+    if protocols:
+        params["protocols"] = [p.strip() for p in protocols.split(",")]
+    execute_operation("POST /vibe-tools/defi/discover", params, output, field)
+
+
+@app.command(name="defi-quote")
+def defi_quote(
+    action: str = typer.Option(..., "--action", help="DeFi action: stake, supply, borrow, add_liquidity"),
+    token: str = typer.Option(..., "--token", help="Token symbol (e.g. 'SOL', 'USDC')"),
+    amount: str = typer.Option(..., "--amount", help="Amount as decimal string"),
+    protocol: Optional[str] = typer.Option(None, "--protocol", help="Protocol name"),
+    output: str = typer.Option("table", "-o", "--output", help="Output format: table, json, raw"),
+    field: Optional[str] = typer.Option(None, "-f", "--field", help="Extract nested field"),
+):
+    """Get DeFi position quote (stake, lend, LP)."""
+    params: dict = {"action": action, "token": token, "amount": amount}
+    if protocol:
+        params["protocol"] = protocol
+    execute_operation("POST /vibe-tools/defi/quote", params, output, field)
+
+
+@app.command(name="defi-deposit")
+def defi_deposit(
+    action: str = typer.Option(..., "--action", help="DeFi action: stake, supply, borrow, add_liquidity"),
+    token: str = typer.Option(..., "--token", help="Token symbol"),
+    amount: str = typer.Option(..., "--amount", help="Amount as decimal string"),
+    protocol: Optional[str] = typer.Option(None, "--protocol", help="Protocol name"),
+    output: str = typer.Option("table", "-o", "--output", help="Output format: table, json, raw"),
+    field: Optional[str] = typer.Option(None, "-f", "--field", help="Extract nested field"),
+):
+    """Execute DeFi deposit (returns unsigned transaction)."""
+    params: dict = {"action": action, "token": token, "amount": amount}
+    if protocol:
+        params["protocol"] = protocol
+    execute_operation("POST /vibe-tools/defi/deposit", params, output, field)
+
+
+# --- bags.fm ---
+
+@app.command(name="bags-launch-token")
+def bags_launch_token(
+    name: str = typer.Option(..., "--name", help="Token name"),
+    symbol: str = typer.Option(..., "--symbol", help="Token symbol"),
+    description: str = typer.Option(..., "--description", help="Token description"),
+    image_url: str = typer.Option(..., "--image-url", help="Token image URL (https)"),
+    output: str = typer.Option("table", "-o", "--output", help="Output format: table, json, raw"),
+    field: Optional[str] = typer.Option(None, "-f", "--field", help="Extract nested field"),
+):
+    """Launch a token on bags.fm."""
+    params: dict = {"name": name, "symbol": symbol, "description": description, "image_url": image_url}
+    execute_operation("POST /vibe-tools/bags/launch-token", params, output, field)
+
+
+@app.command(name="bags-claim-fees")
+def bags_claim_fees(
+    token_mint: str = typer.Option(..., "--token-mint", help="Token mint address"),
+    output: str = typer.Option("table", "-o", "--output", help="Output format: table, json, raw"),
+    field: Optional[str] = typer.Option(None, "-f", "--field", help="Extract nested field"),
+):
+    """Claim bags.fm trading fees."""
+    params: dict = {"token_mint": token_mint}
+    execute_operation("POST /vibe-tools/bags/claim-fees", params, output, field)
+
+
+@app.command(name="bags-positions")
+def bags_positions(
+    output: str = typer.Option("table", "-o", "--output", help="Output format: table, json, raw"),
+    field: Optional[str] = typer.Option(None, "-f", "--field", help="Extract nested field"),
+):
+    """View bags.fm positions and fees."""
+    execute_operation("GET /vibe-tools/bags/positions", {}, output, field)
+
+
+if __name__ == "__main__":
+    app()

vibe_cli-0.1.0/vibe_cli/operations.py

@@ -0,0 +1,181 @@
+"""Dynamic command generation from the /vibe-tools/operations manifest."""
+
+from typing import Any, Callable, Optional
+
+import typer
+from rich.console import Console
+
+from vibe_cli.client import VibeClient
+from vibe_cli.config import get_manifest_cache, save_manifest_cache
+from vibe_cli.output import format_output, print_error
+
+console = Console()
+
+
+# Mapping from manifest path to client method name
+_ROUTE_TO_METHOD = {
+    "POST /vibe-tools/data-provider": "data_provider",
+    "POST /vibe-tools/swap-quote": "swap_quote",
+    "POST /vibe-tools/swap": "swap",
+    "POST /vibe-tools/evm/swap-quote": "evm_swap_quote",
+    "POST /vibe-tools/evm/swap": "evm_swap",
+    "POST /vibe-tools/defi/discover": "defi_discover",
+    "POST /vibe-tools/defi/quote": "defi_quote",
+    "POST /vibe-tools/defi/deposit": "defi_deposit",
+    "POST /vibe-tools/bags/launch-token": "bags_launch_token",
+    "POST /vibe-tools/bags/claim-fees": "bags_claim_fees",
+    "GET /vibe-tools/bags/positions": "bags_positions",
+}
+
+# Parameter definitions for each route (maps CLI flag → request body field)
+_ROUTE_PARAMS = {
+    "POST /vibe-tools/data-provider": [
+        ("--service", "service_name", str, "Provider name (e.g. 'nansen', 'twitter')"),
+        ("--route", "route", str, "Endpoint key (e.g. 'smart_money_netflows')"),
+        ("--payload", "payload", Optional[str], "JSON payload for the provider"),
+    ],
+    "POST /vibe-tools/swap-quote": [
+        ("--from-token", "input_mint", str, "Input token mint address"),
+        ("--to-token", "output_mint", str, "Output token mint address"),
+        ("--amount", "amount", int, "Amount in lamports"),
+        ("--slippage-bps", "slippage_bps", Optional[int], "Slippage in basis points (default 50)"),
+    ],
+    "POST /vibe-tools/swap": [
+        ("--from-token", "input_mint", str, "Input token mint address"),
+        ("--to-token", "output_mint", str, "Output token mint address"),
+        ("--amount", "amount", int, "Amount in lamports"),
+        ("--slippage-bps", "slippage_bps", Optional[int], "Slippage in basis points"),
+    ],
+    "POST /vibe-tools/evm/swap-quote": [
+        ("--network", "network", str, "EVM network: 'base' or 'ethereum'"),
+        ("--from-asset", "from_asset", str, "Source asset (e.g. 'eth', 'usdc')"),
+        ("--to-asset", "to_asset", str, "Destination asset"),
+        ("--amount", "amount", str, "Amount in human-readable units"),
+        ("--slippage-pct", "slippage_pct", Optional[float], "Max slippage percentage"),
+    ],
+    "POST /vibe-tools/evm/swap": [
+        ("--network", "network", str, "EVM network: 'base' or 'ethereum'"),
+        ("--from-asset", "from_asset", str, "Source asset"),
+        ("--to-asset", "to_asset", str, "Destination asset"),
+        ("--amount", "amount", str, "Amount in human-readable units"),
+        ("--slippage-pct", "slippage_pct", Optional[float], "Max slippage percentage"),
+    ],
+    "POST /vibe-tools/defi/discover": [
+        ("--protocols", "protocols", Optional[str], "Comma-separated protocol filter"),
+    ],
+    "POST /vibe-tools/defi/quote": [
+        ("--action", "action", str, "DeFi action: stake, supply, borrow, add_liquidity"),
+        ("--token", "token", str, "Token symbol"),
+        ("--amount", "amount", str, "Amount as decimal string"),
+        ("--protocol", "protocol", Optional[str], "Protocol name"),
+    ],
+    "POST /vibe-tools/defi/deposit": [
+        ("--action", "action", str, "DeFi action: stake, supply, borrow, add_liquidity"),
+        ("--token", "token", str, "Token symbol"),
+        ("--amount", "amount", str, "Amount as decimal string"),
+        ("--protocol", "protocol", Optional[str], "Protocol name"),
+    ],
+    "POST /vibe-tools/bags/launch-token": [
+        ("--name", "name", str, "Token name"),
+        ("--symbol", "symbol", str, "Token symbol"),
+        ("--description", "description", str, "Token description"),
+        ("--image-url", "image_url", str, "Token image URL"),
+    ],
+    "POST /vibe-tools/bags/claim-fees": [
+        ("--token-mint", "token_mint", str, "Token mint address"),
+    ],
+    "GET /vibe-tools/bags/positions": [],
+}
+
+
+def sync_manifest() -> list[dict]:
+    """Fetch the operations manifest from the gateway."""
+    client = VibeClient()
+    response = client.get_operations()
+
+    if "error" in response:
+        print_error(response["error"])
+
+    manifest = response.get("data", [])
+    save_manifest_cache(manifest)
+    return manifest
+
+
+def get_cached_manifest() -> list[dict]:
+    """Get the manifest from cache, or sync if missing."""
+    cached = get_manifest_cache()
+    if cached:
+        return cached
+    return sync_manifest()
+
+
+def list_operations(filter_text: Optional[str] = None) -> None:
+    """List all available operations, optionally filtered."""
+    manifest = get_cached_manifest()
+
+    if filter_text:
+        manifest = [
+            op for op in manifest
+            if filter_text.lower() in op.get("path", "").lower()
+            or filter_text.lower() in op.get("summary", "").lower()
+        ]
+
+    for op in manifest:
+        method = op.get("method", "?")
+        path = op.get("path", "?")
+        summary = op.get("summary", "")
+        scope = op.get("scope", "")
+        rate = op.get("rate_limit", "-")
+
+        console.print(f"  [bold cyan]{method:6s}[/bold cyan] {path}")
+        console.print(f"         [dim]{summary}[/dim]")
+        console.print(f"         scope={scope}  rate={rate}")
+        console.print()
+
+
+def build_route_key(method: str, path: str) -> str:
+    """Build a route key like 'POST /vibe-tools/swap-quote'."""
+    return f"{method} {path}"
+
+
+def execute_operation(
+    route_key: str,
+    params: dict,
+    output_format: str = "table",
+    filter_path: Optional[str] = None,
+) -> None:
+    """Execute a vibe-tools operation by route key."""
+    client = VibeClient()
+    method_name = _ROUTE_TO_METHOD.get(route_key)
+
+    if not method_name:
+        console.print(f"[red]Unknown operation: {route_key}[/red]")
+        raise typer.Exit(1)
+
+    method_func = getattr(client, method_name, None)
+    if not method_func:
+        console.print(f"[red]Client method not found: {method_name}[/red]")
+        raise typer.Exit(1)
+
+    # Clean None values from params
+    clean_params = {k: v for k, v in params.items() if v is not None}
+
+    # Parse JSON payloads
+    if "payload" in clean_params and isinstance(clean_params["payload"], str):
+        import json
+        try:
+            clean_params["payload"] = json.loads(clean_params["payload"])
+        except json.JSONDecodeError:
+            console.print("[red]Invalid JSON payload[/red]")
+            raise typer.Exit(1)
+
+    # Parse comma-separated protocols
+    if "protocols" in clean_params and isinstance(clean_params["protocols"], str):
+        clean_params["protocols"] = [p.strip() for p in clean_params["protocols"].split(",")]
+
+    response = method_func(**clean_params)
+
+    if "error" in response:
+        print_error(response["error"])
+
+    format_output(response.get("data", response), output_format, filter_path)

vibe_cli-0.1.0/vibe_cli/output.py

@@ -0,0 +1,107 @@
+"""Output formatting for the VIBE CLI."""
+
+import json
+from typing import Any, Optional
+
+from rich.console import Console
+from rich.table import Table
+from rich import print_json
+
+console = Console()
+
+
+def format_output(
+    data: Any,
+    output_format: str = "table",
+    filter_path: Optional[str] = None,
+) -> None:
+    """
+    Format and print data in the requested format.
+
+    Args:
+        data: The data to format
+        output_format: One of 'table', 'json', 'raw'
+        filter_path: Dot-path to extract from data (e.g. 'body.data')
+    """
+    # Apply filter path
+    if filter_path and isinstance(data, dict):
+        data = _extract_path(data, filter_path)
+
+    if output_format == "json":
+        if isinstance(data, (dict, list)):
+            console.print_json(json.dumps(data, indent=2))
+        else:
+            console.print_json(json.dumps(data))
+    elif output_format == "raw":
+        if isinstance(data, (dict, list)):
+            console.print(json.dumps(data, indent=2))
+        else:
+            console.print(str(data))
+    else:
+        # Table format — auto-detect best rendering
+        _print_table(data)
+
+
+def _extract_path(data: dict, path: str) -> Any:
+    """Extract a value from nested dict using dot-path notation."""
+    parts = path.split(".")
+    current = data
+    for part in parts:
+        if isinstance(current, dict):
+            current = current.get(part)
+        elif isinstance(current, list) and part.isdigit():
+            idx = int(part)
+            current = current[idx] if idx < len(current) else None
+        else:
+            return None
+    return current
+
+
+def _print_table(data: Any) -> None:
+    """Print data as a rich table or fallback to JSON."""
+    if isinstance(data, list) and len(data) > 0 and isinstance(data[0], dict):
+        # List of dicts → table
+        table = Table(show_header=True, header_style="bold cyan")
+        columns = list(data[0].keys())
+        for col in columns:
+            table.add_column(col)
+        for row in data:
+            table.add_row(*[str(row.get(col, ""))[:80] for col in columns])
+        console.print(table)
+    elif isinstance(data, dict):
+        # Single dict → key-value pairs
+        for key, value in data.items():
+            if isinstance(value, (dict, list)):
+                console.print(f"[bold]{key}:[/bold]")
+                console.print_json(json.dumps(value, indent=2))
+            else:
+                console.print(f"[bold]{key}:[/bold] {value}")
+    else:
+        console.print(str(data))
+
+
+def print_error(error: dict) -> None:
+    """Print an error response from the gateway."""
+    code = error.get("code", "UNKNOWN")
+    message = error.get("message", "Unknown error")
+    retry_after = error.get("retry_after")
+    actions = error.get("actions", [])
+
+    console.print(f"[bold red]{code}[/bold red]: {message}")
+
+    if retry_after:
+        console.print(f"[dim]Retry after {retry_after}s[/dim]")
+
+    for action in actions:
+        console.print(f"[dim]  → {action}[/dim]")
+
+    # Exit code mapping for agent skill error handling
+    import sys
+    code_map = {
+        "UNAUTHORIZED": 4,
+        "FREE_QUOTA_EXHAUSTED": 4,
+        "INSUFFICIENT_CREDITS": 4,
+        "RATE_LIMITED": 4,
+        "FORBIDDEN_SCOPE": 5,
+    }
+    sys.exit(code_map.get(code, 1))

vibe_cli-0.1.0/vibe_cli.egg-info/PKG-INFO

@@ -0,0 +1,89 @@
+Metadata-Version: 2.2
+Name: vibe-cli
+Version: 0.1.0
+Summary: VIBE Airforce CLI — Web3 trading and data at your fingertips
+License: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: typer>=0.12.0
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: pydantic>=2.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: ruff>=0.4.0; extra == "dev"
+
+# vibe-cli
+
+Web3 trading and data at your fingertips.
+
+## Install
+
+```bash
+# pip
+pip install vibe-cli
+
+# pipx (isolated)
+pipx install vibe-cli
+
+# curl | sh
+curl -fsSL https://api.vibe.airforce/api/cli/install.sh | sh
+```
+
+## Quick Start
+
+```bash
+vibe sync                    # Fetch operations manifest (works without API key)
+vibe list-operations         # List all commands
+vibe swap-quote --from-token So11111111111111111111111111111111111111112 \
+                 --to-token EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v \
+                 --amount 1000000
+vibe evm-swap-quote --network base --from-asset eth --to-asset usdc --amount 0.1
+```
+
+## Auth
+
+No API key required to try — 30 free credits per day.
+
+```bash
+vibe auth                    # Paste your API key interactively
+# Or set environment variable
+export VIBE_API_KEY=pk_xxx:sk_xxx
+```
+
+Get your API key at [vibe.airforce/settings/api-keys](https://www.vibe.airforce/settings/api-keys)
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `vibe sync` | Fetch operations manifest |
+| `vibe list-operations` | List available commands |
+| `vibe auth` | Authenticate with API key |
+| `vibe logout` | Remove saved credentials |
+| `vibe swap-quote` | Solana swap quote |
+| `vibe swap` | Execute Solana swap |
+| `vibe evm-swap-quote` | Base/Ethereum swap quote |
+| `vibe evm-swap` | Execute Base/Ethereum swap |
+| `vibe defi-discover` | Discover DeFi protocols |
+| `vibe defi-quote` | Get DeFi position quote |
+| `vibe defi-deposit` | Execute DeFi deposit |
+| `vibe bags-launch-token` | Launch token on bags.fm |
+| `vibe bags-claim-fees` | Claim bags.fm fees |
+| `vibe bags-positions` | View bags.fm positions |
+| `vibe data-provider` | Query external data providers |
+| `vibe feedback` | Submit feedback |
+| `vibe version` | Show CLI version |
+
+## Output Formats
+
+```bash
+vibe swap-quote -o table ...   # Human-readable (default)
+vibe swap-quote -o json ...    # Structured JSON
+vibe swap-quote -o json -f body.data ...  # Extract nested field
+vibe swap-quote -o raw ...     # Unformatted JSON
+```
+
+## License
+
+MIT

vibe_cli-0.1.0/vibe_cli.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+README.md
+pyproject.toml
+vibe_cli/__init__.py
+vibe_cli/auth.py
+vibe_cli/client.py
+vibe_cli/config.py
+vibe_cli/main.py
+vibe_cli/operations.py
+vibe_cli/output.py
+vibe_cli.egg-info/PKG-INFO
+vibe_cli.egg-info/SOURCES.txt
+vibe_cli.egg-info/dependency_links.txt
+vibe_cli.egg-info/entry_points.txt
+vibe_cli.egg-info/requires.txt
+vibe_cli.egg-info/top_level.txt

vibe_cli-0.1.0/vibe_cli.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

vibe_cli-0.1.0/vibe_cli.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+vibe = vibe_cli.main:app

vibe_cli-0.1.0/vibe_cli.egg-info/requires.txt

@@ -0,0 +1,8 @@
+typer>=0.12.0
+httpx>=0.27.0
+rich>=13.0.0
+pydantic>=2.0.0
+
+[dev]
+pytest>=8.0
+ruff>=0.4.0

vibe_cli-0.1.0/vibe_cli.egg-info/top_level.txt

@@ -0,0 +1 @@
+vibe_cli