agentpatch 0.1.0__tar.gz

agentpatch-0.1.0/.github/workflows/ci.yml

@@ -0,0 +1,23 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+jobs:
+  test:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest, windows-latest]
+        python-version: ["3.10", "3.11", "3.12", "3.13"]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+      - run: pip install -e ".[dev]"
+      - run: ruff check src/ tests/
+      - run: ruff format --check src/ tests/
+      - run: pytest tests/ -v

agentpatch-0.1.0/.github/workflows/publish.yml

@@ -0,0 +1,19 @@
+name: Publish to PyPI
+
+on:
+  push:
+    tags: ["v*"]
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - run: pip install build
+      - run: python -m build
+      - uses: pypa/gh-action-pypi-publish@release/v1

agentpatch-0.1.0/.gitignore

@@ -0,0 +1,8 @@
+__pycache__/
+*.pyc
+*.egg-info/
+dist/
+build/
+.venv/
+.pytest_cache/
+.ruff_cache/

agentpatch-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 AgentPatch
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

agentpatch-0.1.0/PKG-INFO

@@ -0,0 +1,124 @@
+Metadata-Version: 2.4
+Name: agentpatch
+Version: 0.1.0
+Summary: Python SDK and CLI for the AgentPatch tool marketplace
+Project-URL: Homepage, https://agentpatch.ai
+Project-URL: Documentation, https://agentpatch.ai/docs/consumer
+Project-URL: Repository, https://github.com/fullthom/agentpatch-python
+Author-email: AgentPatch <hello@agentpatch.ai>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: agent,agentpatch,ai,marketplace,tools
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+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
+Requires-Python: >=3.10
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.5; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# AgentPatch
+
+Zero-dependency Python SDK and CLI for the [AgentPatch](https://agentpatch.ai) tool marketplace. Single file, stdlib only.
+
+## Install
+
+```bash
+pip install agentpatch
+```
+
+Or with [pipx](https://pipx.pypa.io/) for CLI-only usage:
+
+```bash
+pipx install agentpatch
+```
+
+Or just copy `src/agentpatch.py` into your project — it has no dependencies beyond Python 3.10+.
+
+## Authentication
+
+Get your API key from [agentpatch.ai/dashboard](https://agentpatch.ai/dashboard), then either:
+
+```bash
+# Option 1: Save to config file
+ap config set-key
+
+# Option 2: Environment variable
+export AGENTPATCH_API_KEY=ap_your_key_here
+```
+
+## CLI Usage
+
+```bash
+# Search for tools
+ap search "image generation"
+ap search --max-price 100 --json
+
+# Get tool details
+ap info agentpatch google-search
+
+# Invoke a tool (waits for result by default)
+ap run agentpatch google-search --input '{"query": "best pizza NYC"}'
+
+# Invoke without waiting (for async tools)
+ap run agentpatch generate-image-recraft --input '{"prompt": "a cat"}' --no-poll
+
+# Check async job status
+ap job job_abc123
+ap job job_abc123 --poll    # wait for completion
+```
+
+Every command supports `--json` for scripting:
+
+```bash
+ap search "email" --json | jq '.[0].slug'
+ap run agentpatch google-search --input '{"query": "test"}' --json | jq '.output'
+```
+
+## SDK Usage
+
+```python
+from agentpatch import AgentPatch
+
+ap = AgentPatch()  # uses AGENTPATCH_API_KEY env var or ~/.agentpatch/config.toml
+
+# Search for tools
+tools = ap.search("image generation")
+for t in tools["tools"]:
+    print(f"{t['owner_username']}/{t['slug']} — {t['price_credits_per_call']} credits")
+
+# Get tool details
+tool = ap.get_tool("agentpatch", "google-search")
+print(tool["input_schema"])
+
+# Invoke a tool (auto-polls async jobs)
+result = ap.invoke("agentpatch", "google-search", {"query": "best pizza NYC"})
+print(result["output"])
+
+# Manual async control
+result = ap.invoke("agentpatch", "generate-image-recraft", {"prompt": "a cat"}, poll=False)
+job = ap.get_job(result["job_id"])
+```
+
+## Configuration
+
+API key resolution order:
+1. `api_key=` parameter (SDK) or `--api-key` flag (CLI)
+2. `AGENTPATCH_API_KEY` environment variable
+3. `~/.agentpatch/config.toml` file
+
+```bash
+ap config set-key    # save API key
+ap config show       # show current config
+ap config clear      # delete config file
+```
+
+## License
+
+MIT

agentpatch-0.1.0/README.md

@@ -0,0 +1,99 @@
+# AgentPatch
+
+Zero-dependency Python SDK and CLI for the [AgentPatch](https://agentpatch.ai) tool marketplace. Single file, stdlib only.
+
+## Install
+
+```bash
+pip install agentpatch
+```
+
+Or with [pipx](https://pipx.pypa.io/) for CLI-only usage:
+
+```bash
+pipx install agentpatch
+```
+
+Or just copy `src/agentpatch.py` into your project — it has no dependencies beyond Python 3.10+.
+
+## Authentication
+
+Get your API key from [agentpatch.ai/dashboard](https://agentpatch.ai/dashboard), then either:
+
+```bash
+# Option 1: Save to config file
+ap config set-key
+
+# Option 2: Environment variable
+export AGENTPATCH_API_KEY=ap_your_key_here
+```
+
+## CLI Usage
+
+```bash
+# Search for tools
+ap search "image generation"
+ap search --max-price 100 --json
+
+# Get tool details
+ap info agentpatch google-search
+
+# Invoke a tool (waits for result by default)
+ap run agentpatch google-search --input '{"query": "best pizza NYC"}'
+
+# Invoke without waiting (for async tools)
+ap run agentpatch generate-image-recraft --input '{"prompt": "a cat"}' --no-poll
+
+# Check async job status
+ap job job_abc123
+ap job job_abc123 --poll    # wait for completion
+```
+
+Every command supports `--json` for scripting:
+
+```bash
+ap search "email" --json | jq '.[0].slug'
+ap run agentpatch google-search --input '{"query": "test"}' --json | jq '.output'
+```
+
+## SDK Usage
+
+```python
+from agentpatch import AgentPatch
+
+ap = AgentPatch()  # uses AGENTPATCH_API_KEY env var or ~/.agentpatch/config.toml
+
+# Search for tools
+tools = ap.search("image generation")
+for t in tools["tools"]:
+    print(f"{t['owner_username']}/{t['slug']} — {t['price_credits_per_call']} credits")
+
+# Get tool details
+tool = ap.get_tool("agentpatch", "google-search")
+print(tool["input_schema"])
+
+# Invoke a tool (auto-polls async jobs)
+result = ap.invoke("agentpatch", "google-search", {"query": "best pizza NYC"})
+print(result["output"])
+
+# Manual async control
+result = ap.invoke("agentpatch", "generate-image-recraft", {"prompt": "a cat"}, poll=False)
+job = ap.get_job(result["job_id"])
+```
+
+## Configuration
+
+API key resolution order:
+1. `api_key=` parameter (SDK) or `--api-key` flag (CLI)
+2. `AGENTPATCH_API_KEY` environment variable
+3. `~/.agentpatch/config.toml` file
+
+```bash
+ap config set-key    # save API key
+ap config show       # show current config
+ap config clear      # delete config file
+```
+
+## License
+
+MIT

agentpatch-0.1.0/pyproject.toml

@@ -0,0 +1,50 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "agentpatch"
+version = "0.1.0"
+description = "Python SDK and CLI for the AgentPatch tool marketplace"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.10"
+authors = [
+    { name = "AgentPatch", email = "hello@agentpatch.ai" },
+]
+keywords = ["agentpatch", "ai", "tools", "marketplace", "agent"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+]
+dependencies = []
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0",
+    "ruff>=0.5",
+]
+
+[project.scripts]
+ap = "agentpatch:main"
+
+[project.urls]
+Homepage = "https://agentpatch.ai"
+Documentation = "https://agentpatch.ai/docs/consumer"
+Repository = "https://github.com/fullthom/agentpatch-python"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/agentpatch.py"]
+
+[tool.ruff]
+target-version = "py310"
+line-length = 120
+
+[tool.ruff.lint]
+select = ["E", "F", "I"]

agentpatch-0.1.0/src/agentpatch.py

@@ -0,0 +1,558 @@
+"""AgentPatch — Python SDK and CLI for the AgentPatch tool marketplace.
+
+Zero-dependency, single-file package. Uses only the Python standard library.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+import time
+import urllib.error
+import urllib.parse
+import urllib.request
+from pathlib import Path
+from typing import Any
+
+__all__ = ["AgentPatch", "AgentPatchError"]
+__version__ = "0.1.0"
+
+# ---------------------------------------------------------------------------
+# Config
+# ---------------------------------------------------------------------------
+
+CONFIG_DIR = Path.home() / ".agentpatch"
+CONFIG_FILE = CONFIG_DIR / "config.toml"
+
+
+def resolve_api_key(explicit: str | None = None) -> str | None:
+    """Resolve API key from: explicit param > env var > config file."""
+    if explicit:
+        return explicit
+    from_env = os.environ.get("AGENTPATCH_API_KEY")
+    if from_env:
+        return from_env
+    return _load_from_config()
+
+
+def _load_from_config() -> str | None:
+    """Read API key from ~/.agentpatch/config.toml."""
+    if not CONFIG_FILE.exists():
+        return None
+    try:
+        if sys.version_info >= (3, 11):
+            import tomllib
+        else:
+            import tomli as tomllib  # type: ignore[no-redef]
+        data = tomllib.loads(CONFIG_FILE.read_text())
+        return data.get("api_key")
+    except Exception:
+        for line in CONFIG_FILE.read_text().splitlines():
+            line = line.strip()
+            if line.startswith("api_key"):
+                _, _, value = line.partition("=")
+                return value.strip().strip('"').strip("'")
+        return None
+
+
+def save_api_key(api_key: str) -> Path:
+    """Save API key to ~/.agentpatch/config.toml. Returns the config file path."""
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    CONFIG_FILE.write_text(f'api_key = "{api_key}"\n')
+    try:
+        CONFIG_FILE.chmod(0o600)
+    except OSError:
+        pass  # Windows may not support chmod
+    return CONFIG_FILE
+
+
+def clear_config() -> None:
+    """Delete the config file."""
+    if CONFIG_FILE.exists():
+        CONFIG_FILE.unlink()
+
+
+# ---------------------------------------------------------------------------
+# HTTP helper
+# ---------------------------------------------------------------------------
+
+def _request(
+    method: str,
+    url: str,
+    headers: dict[str, str],
+    body: bytes | None = None,
+    timeout: float = 120.0,
+) -> tuple[int, dict[str, Any]]:
+    """Make an HTTP request and return (status_code, parsed_json)."""
+    req = urllib.request.Request(url, data=body, headers=headers, method=method)
+    if body is not None:
+        req.add_header("Content-Type", "application/json")
+    try:
+        with urllib.request.urlopen(req, timeout=timeout) as resp:
+            data = json.loads(resp.read().decode())
+            return resp.status, data
+    except urllib.error.HTTPError as e:
+        body = e.read().decode()
+        try:
+            data = json.loads(body)
+        except (json.JSONDecodeError, ValueError):
+            data = {"error": body or f"HTTP {e.code}"}
+        return e.code, data
+
+
+# ---------------------------------------------------------------------------
+# Client
+# ---------------------------------------------------------------------------
+
+DEFAULT_BASE_URL = "https://agentpatch.ai"
+DEFAULT_TIMEOUT = 120.0
+DEFAULT_POLL_INTERVAL = 5.0
+DEFAULT_POLL_TIMEOUT = 300.0
+
+
+class AgentPatchError(Exception):
+    """Base exception for AgentPatch API errors."""
+
+    def __init__(self, message: str, status_code: int | None = None, body: dict[str, Any] | None = None) -> None:
+        super().__init__(message)
+        self.status_code = status_code
+        self.body = body
+
+
+class AgentPatch:
+    """Client for the AgentPatch tool marketplace.
+
+    Args:
+        api_key: API key. Falls back to AGENTPATCH_API_KEY env var, then ~/.agentpatch/config.toml.
+        base_url: API base URL (default: https://agentpatch.ai).
+        timeout: HTTP request timeout in seconds (default: 120).
+    """
+
+    def __init__(
+        self,
+        api_key: str | None = None,
+        base_url: str = DEFAULT_BASE_URL,
+        timeout: float = DEFAULT_TIMEOUT,
+    ) -> None:
+        self._api_key = resolve_api_key(api_key)
+        self._base_url = base_url.rstrip("/")
+        self._timeout = timeout
+        self._headers: dict[str, str] = {"User-Agent": f"agentpatch-python/{__version__}"}
+        if self._api_key:
+            self._headers["Authorization"] = f"Bearer {self._api_key}"
+
+    def search(
+        self,
+        query: str | None = None,
+        *,
+        min_success_rate: float | None = None,
+        max_price_credits: int | None = None,
+        limit: int = 20,
+    ) -> dict[str, Any]:
+        """Search the marketplace for tools. Returns {"tools": [...], "count": N}."""
+        params: dict[str, Any] = {"limit": limit}
+        if query is not None:
+            params["q"] = query
+        if min_success_rate is not None:
+            params["min_success_rate"] = min_success_rate
+        if max_price_credits is not None:
+            params["max_price_credits"] = max_price_credits
+        return self._get("/api/search", params=params)
+
+    def get_tool(self, username: str, slug: str) -> dict[str, Any]:
+        """Get detailed information about a specific tool."""
+        return self._get(f"/api/tools/{username}/{slug}")
+
+    def invoke(
+        self,
+        username: str,
+        slug: str,
+        input: dict[str, Any],
+        *,
+        timeout_seconds: int | None = None,
+        poll: bool = True,
+        poll_interval: float = DEFAULT_POLL_INTERVAL,
+        poll_timeout: float = DEFAULT_POLL_TIMEOUT,
+    ) -> dict[str, Any]:
+        """Invoke a tool. Auto-polls async jobs to completion by default.
+
+        Pass poll=False to return immediately with job_id for manual polling.
+        """
+        self._require_auth()
+        params: dict[str, Any] = {}
+        if timeout_seconds is not None:
+            params["timeout_seconds"] = timeout_seconds
+
+        url = f"{self._base_url}/api/tools/{username}/{slug}"
+        if params:
+            url += "?" + urllib.parse.urlencode(params)
+
+        status, data = _request("POST", url, self._headers, json.dumps(input).encode(), self._timeout)
+
+        if status >= 400:
+            raise AgentPatchError(data.get("error", "Request failed"), status, data)
+
+        if not poll or data.get("status") != "pending":
+            return data
+
+        # Poll until completion
+        job_id = data["job_id"]
+        start = time.monotonic()
+        while time.monotonic() - start < poll_timeout:
+            time.sleep(poll_interval)
+            job = self.get_job(job_id)
+            if job["status"] in ("success", "failed", "timeout"):
+                return job
+        raise AgentPatchError(f"Job {job_id} did not complete within {poll_timeout}s")
+
+    def get_job(self, job_id: str) -> dict[str, Any]:
+        """Check the status of an async job."""
+        self._require_auth()
+        return self._get(f"/api/jobs/{job_id}")
+
+    def _get(self, path: str, params: dict[str, Any] | None = None) -> dict[str, Any]:
+        """Make a GET request and return parsed JSON."""
+        url = f"{self._base_url}{path}"
+        if params:
+            url += "?" + urllib.parse.urlencode(params)
+        status, data = _request("GET", url, self._headers, timeout=self._timeout)
+        if status >= 400:
+            raise AgentPatchError(data.get("error", "Request failed"), status, data)
+        return data
+
+    def _require_auth(self) -> None:
+        """Raise if no API key is configured."""
+        if not self._api_key:
+            raise AgentPatchError(
+                "No API key configured. Set AGENTPATCH_API_KEY env var, "
+                "run 'ap config set-key', or pass api_key= to AgentPatch()."
+            )
+
+    def close(self) -> None:
+        """Close the client (no-op — urllib doesn't need connection management)."""
+
+    def __enter__(self) -> AgentPatch:
+        return self
+
+    def __exit__(self, *args: Any) -> None:
+        self.close()
+
+
+# ---------------------------------------------------------------------------
+# CLI helpers
+# ---------------------------------------------------------------------------
+
+_ANSI = sys.stdout.isatty()
+
+
+def _green(text: str) -> str:
+    return f"\033[32m{text}\033[0m" if _ANSI else text
+
+
+def _red(text: str) -> str:
+    return f"\033[31m{text}\033[0m" if _ANSI else text
+
+
+def _yellow(text: str) -> str:
+    return f"\033[33m{text}\033[0m" if _ANSI else text
+
+
+def _bold(text: str) -> str:
+    return f"\033[1m{text}\033[0m" if _ANSI else text
+
+
+def _dim(text: str) -> str:
+    return f"\033[2m{text}\033[0m" if _ANSI else text
+
+
+def _print_table(headers: list[str], rows: list[list[str]], title: str | None = None) -> None:
+    """Print a simple column-aligned table."""
+    if not rows:
+        return
+    col_widths = [len(h) for h in headers]
+    for row in rows:
+        for i, cell in enumerate(row):
+            col_widths[i] = max(col_widths[i], len(cell))
+
+    if title:
+        print(f"\n  {title}")
+
+    header_line = "  ".join(h.ljust(col_widths[i]) for i, h in enumerate(headers))
+    print(f"  {header_line}")
+    print(f"  {'  '.join('-' * w for w in col_widths)}")
+    for row in rows:
+        line = "  ".join(cell.ljust(col_widths[i]) for i, cell in enumerate(row))
+        print(f"  {line}")
+    print()
+
+
+def _output_json(data: Any) -> None:
+    """Print raw JSON to stdout."""
+    print(json.dumps(data, indent=2))
+
+
+def _error(message: str) -> None:
+    """Print error and exit."""
+    print(f"{_red('Error:')} {message}", file=sys.stderr)
+    sys.exit(1)
+
+
+# ---------------------------------------------------------------------------
+# CLI subcommands
+# ---------------------------------------------------------------------------
+
+def _cmd_search(args: argparse.Namespace) -> None:
+    """Handle 'search' subcommand."""
+    client = AgentPatch(api_key=args.api_key, base_url=args.base_url)
+    try:
+        result = client.search(
+            args.query,
+            limit=args.limit,
+            max_price_credits=args.max_price,
+            min_success_rate=args.min_rate,
+        )
+    except AgentPatchError as e:
+        _error(str(e))
+
+    if args.json:
+        _output_json(result)
+        return
+
+    tools = result.get("tools", [])
+    if not tools:
+        print("No tools found.")
+        return
+
+    rows: list[list[str]] = []
+    for t in tools:
+        price = t.get("price_credits_per_call", 0)
+        rate = t.get("success_rate")
+        rate_str = f"{rate:.0%}" if rate is not None else "-"
+        owner = t.get("owner_username", "")
+        rows.append([
+            f"{owner}/{t['slug']}",
+            t.get("description", "")[:50],
+            f"{price} cr",
+            rate_str,
+        ])
+
+    _print_table(
+        ["Tool", "Description", "Price", "Success"],
+        rows,
+        title=f"Found {result.get('count', len(tools))} tools",
+    )
+
+
+def _cmd_info(args: argparse.Namespace) -> None:
+    """Handle 'info' subcommand."""
+    client = AgentPatch(api_key=args.api_key, base_url=args.base_url)
+    try:
+        tool = client.get_tool(args.username, args.slug)
+    except AgentPatchError as e:
+        _error(str(e))
+
+    if args.json:
+        _output_json(tool)
+        return
+
+    rate = tool.get("success_rate")
+    rate_str = f"{rate * 100:.0f}%" if rate else "-"
+    print(f"\n{_bold(tool.get('name', args.slug))}")
+    print(
+        f"by {tool.get('owner_username', args.username)} | "
+        f"{tool.get('price_credits_per_call', '?')} credits/call | "
+        f"{rate_str} success rate | "
+        f"{tool.get('total_calls', 0) or 0} total calls\n"
+    )
+    print(f"{tool.get('description', '')}\n")
+
+    input_schema = tool.get("input_schema", {})
+    if input_schema.get("properties"):
+        print(f"{_bold('Input Schema:')}")
+        print(json.dumps(input_schema, indent=2))
+
+
+def _cmd_run(args: argparse.Namespace) -> None:
+    """Handle 'run' subcommand."""
+    try:
+        tool_input = json.loads(args.input)
+    except json.JSONDecodeError as e:
+        _error(f"Invalid JSON input: {e}")
+
+    client = AgentPatch(api_key=args.api_key, base_url=args.base_url)
+
+    try:
+        result = client.invoke(
+            args.username,
+            args.slug,
+            tool_input,
+            timeout_seconds=args.timeout,
+            poll=not args.no_poll,
+        )
+    except AgentPatchError as e:
+        _error(str(e))
+
+    if args.json:
+        _output_json(result)
+        return
+
+    status = result.get("status", "unknown")
+    if status == "success":
+        credits = result.get("credits_used", 0)
+        latency = result.get("latency_ms")
+        meta = f"{credits} credits"
+        if latency:
+            meta += f", {latency}ms"
+        print(f"{_green('Success')} ({meta})\n")
+        output = result.get("output")
+        if output is not None:
+            print(json.dumps(output, indent=2, default=str))
+    elif status == "pending":
+        print(f"{_yellow('Job started:')} {result.get('job_id')}")
+        print(f"Poll with: ap job {result.get('job_id')}")
+    elif status == "failed":
+        print(f"{_red('Failed:')} {result.get('error', 'Unknown error')}")
+    else:
+        _output_json(result)
+
+
+def _cmd_job(args: argparse.Namespace) -> None:
+    """Handle 'job' subcommand."""
+    client = AgentPatch(api_key=args.api_key, base_url=args.base_url)
+
+    try:
+        if args.poll:
+            start = time.monotonic()
+            while True:
+                result = client.get_job(args.job_id)
+                if result.get("status") in ("success", "failed", "timeout"):
+                    break
+                if time.monotonic() - start > 300:
+                    _error("Timed out waiting for job")
+                time.sleep(5)
+        else:
+            result = client.get_job(args.job_id)
+    except AgentPatchError as e:
+        _error(str(e))
+
+    if args.json:
+        _output_json(result)
+        return
+
+    status = result.get("status", "unknown")
+    print(f"Job:     {result.get('job_id', args.job_id)}")
+    print(f"Status:  {status}")
+    if result.get("credits_used") is not None:
+        print(f"Credits: {result['credits_used']}")
+    if result.get("latency_ms") is not None:
+        print(f"Latency: {result['latency_ms']}ms")
+
+    output = result.get("output")
+    if output is not None:
+        print()
+        print(json.dumps(output, indent=2, default=str))
+
+    if result.get("error"):
+        print(f"\n{_red('Error:')} {result['error']}")
+
+
+def _cmd_config_set_key(args: argparse.Namespace) -> None:
+    """Handle 'config set-key' subcommand."""
+    api_key = input("Enter your AgentPatch API key: ")
+    path = save_api_key(api_key)
+    print(f"API key saved to {path}")
+    print("Get your key at: https://agentpatch.ai/dashboard")
+
+
+def _cmd_config_show(args: argparse.Namespace) -> None:
+    """Handle 'config show' subcommand."""
+    key = resolve_api_key()
+    if key:
+        masked = key[:6] + "..." + key[-4:] if len(key) > 10 else "****"
+        print(f"API key: {masked}")
+    else:
+        print(f"API key: {_dim('not set')}")
+    print(f"Config:  {CONFIG_FILE}")
+
+
+def _cmd_config_clear(args: argparse.Namespace) -> None:
+    """Handle 'config clear' subcommand."""
+    clear_config()
+    print("Config cleared.")
+
+
+# ---------------------------------------------------------------------------
+# CLI entry point
+# ---------------------------------------------------------------------------
+
+def main(argv: list[str] | None = None) -> None:
+    """CLI entry point. Pass argv for testing, or None to use sys.argv."""
+    parser = argparse.ArgumentParser(prog="ap", description="AgentPatch — discover and use AI tools from the CLI.")
+    parser.add_argument("--api-key", default=os.environ.get("AGENTPATCH_API_KEY"), help="API key (overrides config).")
+    parser.add_argument("--base-url", default="https://agentpatch.ai", help="API base URL.")
+
+    subparsers = parser.add_subparsers(dest="command")
+
+    # search
+    p_search = subparsers.add_parser("search", help="Search for tools in the marketplace.")
+    p_search.add_argument("query", nargs="?", default=None)
+    p_search.add_argument("--limit", type=int, default=20, help="Max results (1-100).")
+    p_search.add_argument("--max-price", type=int, default=None, help="Max price in credits.")
+    p_search.add_argument("--min-rate", type=float, default=None, help="Min success rate (0-1).")
+    p_search.add_argument("--json", action="store_true", help="Output raw JSON.")
+    p_search.set_defaults(func=_cmd_search)
+
+    # info
+    p_info = subparsers.add_parser("info", help="Get details about a specific tool.")
+    p_info.add_argument("username")
+    p_info.add_argument("slug")
+    p_info.add_argument("--json", action="store_true", help="Output raw JSON.")
+    p_info.set_defaults(func=_cmd_info)
+
+    # run
+    p_run = subparsers.add_parser("run", help="Invoke a tool with input data.")
+    p_run.add_argument("username")
+    p_run.add_argument("slug")
+    p_run.add_argument("--input", required=True, help="Tool input as JSON string.")
+    p_run.add_argument("--no-poll", action="store_true", help="Don't wait for async results.")
+    p_run.add_argument("--timeout", type=int, default=None, help="Server-side timeout (1-3600s).")
+    p_run.add_argument("--json", action="store_true", help="Output raw JSON.")
+    p_run.set_defaults(func=_cmd_run)
+
+    # job
+    p_job = subparsers.add_parser("job", help="Check the status of an async job.")
+    p_job.add_argument("job_id")
+    p_job.add_argument("--poll", action="store_true", help="Poll until job completes.")
+    p_job.add_argument("--json", action="store_true", help="Output raw JSON.")
+    p_job.set_defaults(func=_cmd_job)
+
+    # config (with sub-subcommands)
+    p_config = subparsers.add_parser("config", help="Manage API key and configuration.")
+    config_sub = p_config.add_subparsers(dest="config_command")
+
+    p_set_key = config_sub.add_parser("set-key", help="Save your API key.")
+    p_set_key.set_defaults(func=_cmd_config_set_key)
+
+    p_show = config_sub.add_parser("show", help="Show current configuration.")
+    p_show.set_defaults(func=_cmd_config_show)
+
+    p_clear = config_sub.add_parser("clear", help="Delete the config file.")
+    p_clear.set_defaults(func=_cmd_config_clear)
+
+    args = parser.parse_args(argv)
+
+    if not args.command:
+        parser.print_help()
+        sys.exit(0)
+
+    if args.command == "config" and not args.config_command:
+        p_config.print_help()
+        sys.exit(0)
+
+    args.func(args)
+
+
+if __name__ == "__main__":
+    main()

agentpatch-0.1.0/tests/test_agentpatch.py

@@ -0,0 +1,298 @@
+"""Tests for the AgentPatch SDK and CLI (single-file, zero-dependency version)."""
+
+from __future__ import annotations
+
+import contextlib
+import io
+import json
+from pathlib import Path
+from typing import Any
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from agentpatch import AgentPatch, AgentPatchError, main
+
+BASE = "https://agentpatch.ai"
+
+SEARCH_RESPONSE = {
+    "tools": [
+        {
+            "slug": "google-search",
+            "name": "Google Search",
+            "description": "Search the web",
+            "price_credits_per_call": 50,
+            "input_schema": {"type": "object", "properties": {"query": {"type": "string"}}},
+            "output_schema": {"type": "object"},
+            "owner_username": "agentpatch",
+            "success_rate": 0.99,
+            "total_calls": 1000,
+            "avg_latency_ms": 500,
+        }
+    ],
+    "count": 1,
+}
+
+TOOL_DETAIL = {
+    "slug": "google-search",
+    "name": "Google Search",
+    "description": "Search the web via Google",
+    "price_credits_per_call": 50,
+    "input_schema": {"type": "object", "properties": {"query": {"type": "string"}}},
+    "output_schema": {"type": "object"},
+    "owner_username": "agentpatch",
+    "success_rate": 0.99,
+    "total_calls": 1000,
+    "avg_latency_ms": 500,
+    "default_timeout_seconds": 60,
+    "max_timeout_seconds": 600,
+}
+
+INVOKE_SUCCESS = {
+    "job_id": "job_123",
+    "status": "success",
+    "output": {"results": [{"title": "Test"}]},
+    "latency_ms": 450,
+    "credits_used": 50,
+    "credits_remaining": 9950,
+}
+
+INVOKE_PENDING = {
+    "job_id": "job_456",
+    "status": "pending",
+    "poll_url": "/api/jobs/job_456",
+    "credits_reserved": 800,
+    "credits_remaining": 9200,
+}
+
+JOB_SUCCESS = {
+    "job_id": "job_456",
+    "tool_id": "tool_abc",
+    "status": "success",
+    "output": {"image_url": "https://example.com/img.png"},
+    "latency_ms": 12000,
+    "credits_used": 800,
+    "credits_remaining": 9200,
+    "created_at": "2026-03-01T00:00:00Z",
+    "completed_at": "2026-03-01T00:00:12Z",
+}
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+def _mock_response(status: int, body: dict[str, Any]) -> MagicMock:
+    """Create a mock that simulates urllib.request.urlopen return value."""
+    resp = MagicMock()
+    resp.status = status
+    resp.read.return_value = json.dumps(body).encode()
+    resp.__enter__ = lambda s: s
+    resp.__exit__ = MagicMock(return_value=False)
+    return resp
+
+
+def _mock_http_error(status: int, body: dict[str, Any]) -> Exception:
+    """Create a urllib.error.HTTPError with JSON body."""
+    import urllib.error
+
+    err = urllib.error.HTTPError(
+        url="https://agentpatch.ai/api/test",
+        code=status,
+        msg="Error",
+        hdrs=None,  # type: ignore[arg-type]
+        fp=io.BytesIO(json.dumps(body).encode()),
+    )
+    return err
+
+
+def _run_cli(argv: list[str]) -> tuple[str, int]:
+    """Run the CLI main() capturing stdout. Returns (output, exit_code)."""
+    buf = io.StringIO()
+    exit_code = 0
+    try:
+        with contextlib.redirect_stdout(buf):
+            main(argv)
+    except SystemExit as e:
+        exit_code = e.code if isinstance(e.code, int) else 1
+    return buf.getvalue(), exit_code
+
+
+# ---------------------------------------------------------------------------
+# SDK tests
+# ---------------------------------------------------------------------------
+
+class TestSearch:
+    def test_search(self) -> None:
+        with patch("agentpatch._request", return_value=(200, SEARCH_RESPONSE)):
+            with AgentPatch(api_key="test_key") as ap:
+                result = ap.search()
+        assert result["count"] == 1
+        assert result["tools"][0]["slug"] == "google-search"
+
+    def test_search_with_query(self) -> None:
+        with patch("agentpatch._request", return_value=(200, SEARCH_RESPONSE)) as mock:
+            with AgentPatch(api_key="test_key") as ap:
+                result = ap.search("image", limit=10)
+        assert result["count"] == 1
+        call_url = mock.call_args[0][1]
+        assert "q=image" in call_url
+        assert "limit=10" in call_url
+
+
+class TestGetTool:
+    def test_get_tool(self) -> None:
+        with patch("agentpatch._request", return_value=(200, TOOL_DETAIL)):
+            with AgentPatch(api_key="test_key") as ap:
+                tool = ap.get_tool("agentpatch", "google-search")
+        assert tool["name"] == "Google Search"
+        assert tool["default_timeout_seconds"] == 60
+
+    def test_get_tool_not_found(self) -> None:
+        with patch("agentpatch._request", return_value=(404, {"error": "Tool not found"})):
+            with AgentPatch(api_key="test_key") as ap:
+                with pytest.raises(AgentPatchError) as exc_info:
+                    ap.get_tool("nobody", "fake")
+        assert exc_info.value.status_code == 404
+
+
+class TestInvoke:
+    def test_invoke_sync(self) -> None:
+        with patch("agentpatch._request", return_value=(200, INVOKE_SUCCESS)):
+            with AgentPatch(api_key="test_key") as ap:
+                result = ap.invoke("agentpatch", "google-search", {"query": "test"})
+        assert result["status"] == "success"
+        assert result["output"]["results"][0]["title"] == "Test"
+
+    def test_invoke_async_with_poll(self) -> None:
+        responses = [(202, INVOKE_PENDING), (200, JOB_SUCCESS)]
+        call_count = 0
+
+        def fake_request(*args: Any, **kwargs: Any) -> tuple[int, dict[str, Any]]:
+            nonlocal call_count
+            resp = responses[call_count]
+            call_count += 1
+            return resp
+
+        with patch("agentpatch._request", side_effect=fake_request), patch("time.sleep"):
+            with AgentPatch(api_key="test_key") as ap:
+                result = ap.invoke("agentpatch", "recraft", {"prompt": "a cat"}, poll_interval=0.01)
+        assert result["status"] == "success"
+        assert result["output"]["image_url"] == "https://example.com/img.png"
+
+    def test_invoke_no_poll(self) -> None:
+        with patch("agentpatch._request", return_value=(202, INVOKE_PENDING)):
+            with AgentPatch(api_key="test_key") as ap:
+                result = ap.invoke("agentpatch", "recraft", {"prompt": "a cat"}, poll=False)
+        assert result["status"] == "pending"
+        assert result["job_id"] == "job_456"
+
+    def test_invoke_requires_auth(self) -> None:
+        with AgentPatch() as ap:
+            with pytest.raises(AgentPatchError, match="No API key"):
+                ap.invoke("agentpatch", "google-search", {"query": "test"})
+
+    def test_invoke_error(self) -> None:
+        error_body = {"error": "Insufficient credits", "required": 50, "balance": 10}
+        with patch("agentpatch._request", return_value=(402, error_body)):
+            with AgentPatch(api_key="test_key") as ap:
+                with pytest.raises(AgentPatchError) as exc_info:
+                    ap.invoke("agentpatch", "google-search", {"query": "test"})
+        assert exc_info.value.status_code == 402
+        assert exc_info.value.body["balance"] == 10
+
+
+class TestGetJob:
+    def test_get_job(self) -> None:
+        with patch("agentpatch._request", return_value=(200, JOB_SUCCESS)):
+            with AgentPatch(api_key="test_key") as ap:
+                job = ap.get_job("job_456")
+        assert job["status"] == "success"
+        assert job["credits_used"] == 800
+
+    def test_get_job_requires_auth(self) -> None:
+        with AgentPatch() as ap:
+            with pytest.raises(AgentPatchError, match="No API key"):
+                ap.get_job("job_123")
+
+
+# ---------------------------------------------------------------------------
+# CLI tests
+# ---------------------------------------------------------------------------
+
+class TestCLISearch:
+    def test_search_table(self) -> None:
+        with patch("agentpatch._request", return_value=(200, SEARCH_RESPONSE)):
+            output, code = _run_cli(["--api-key", "test", "search"])
+        assert code == 0
+        assert "google-search" in output
+
+    def test_search_json(self) -> None:
+        with patch("agentpatch._request", return_value=(200, SEARCH_RESPONSE)):
+            output, code = _run_cli(["--api-key", "test", "search", "web", "--json"])
+        assert code == 0
+        data = json.loads(output)
+        assert data["count"] == 1
+
+
+class TestCLIInfo:
+    def test_info(self) -> None:
+        with patch("agentpatch._request", return_value=(200, TOOL_DETAIL)):
+            output, code = _run_cli(["--api-key", "test", "info", "agentpatch", "google-search"])
+        assert code == 0
+        assert "Google Search" in output
+
+
+class TestCLIRun:
+    def test_run_success(self) -> None:
+        with patch("agentpatch._request", return_value=(200, INVOKE_SUCCESS)):
+            output, code = _run_cli([
+                "--api-key", "test",
+                "run", "agentpatch", "google-search",
+                "--input", '{"query": "test"}',
+            ])
+        assert code == 0
+        assert "Success" in output
+
+    def test_run_json(self) -> None:
+        with patch("agentpatch._request", return_value=(200, INVOKE_SUCCESS)):
+            output, code = _run_cli([
+                "--api-key", "test",
+                "run", "agentpatch", "google-search",
+                "--input", '{"query": "test"}',
+                "--json",
+            ])
+        assert code == 0
+        data = json.loads(output)
+        assert data["status"] == "success"
+
+
+class TestCLIConfig:
+    def test_config_set_key(self, tmp_path: Any, monkeypatch: pytest.MonkeyPatch) -> None:
+        config_file = tmp_path / "config.toml"
+        monkeypatch.setattr("agentpatch.CONFIG_FILE", config_file)
+        monkeypatch.setattr("agentpatch.CONFIG_DIR", tmp_path)
+        monkeypatch.setattr("builtins.input", lambda _: "my_secret_key")
+
+        output, code = _run_cli(["config", "set-key"])
+        assert code == 0
+        assert "saved" in output
+        assert config_file.read_text().strip() == 'api_key = "my_secret_key"'
+
+    def test_config_show_no_key(self, monkeypatch: pytest.MonkeyPatch) -> None:
+        monkeypatch.delenv("AGENTPATCH_API_KEY", raising=False)
+        monkeypatch.setattr("agentpatch.CONFIG_FILE", Path("/nonexistent/config.toml"))
+
+        output, code = _run_cli(["config", "show"])
+        assert code == 0
+        assert "not set" in output or "Config" in output
+
+    def test_config_clear(self, tmp_path: Any, monkeypatch: pytest.MonkeyPatch) -> None:
+        config_file = tmp_path / "config.toml"
+        config_file.write_text('api_key = "test"\n')
+        monkeypatch.setattr("agentpatch.CONFIG_FILE", config_file)
+
+        output, code = _run_cli(["config", "clear"])
+        assert code == 0
+        assert "cleared" in output
+        assert not config_file.exists()