clawsy 0.1.0__tar.gz

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

@@ -0,0 +1,29 @@
+name: Publish to PyPI
+
+on:
+  release:
+    types: [published]
+  workflow_dispatch:
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Install build tools
+        run: pip install build twine
+
+      - name: Build package
+        run: python -m build
+
+      - name: Publish to PyPI
+        run: twine upload dist/*
+        env:
+          TWINE_USERNAME: __token__
+          TWINE_PASSWORD: ${{ secrets.PYPI_API_TOKEN }}

clawsy-0.1.0/.gitignore

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

clawsy-0.1.0/PKG-INFO

@@ -0,0 +1,68 @@
+Metadata-Version: 2.4
+Name: clawsy
+Version: 0.1.0
+Summary: Distributed AI agent worker CLI for Clawsy AgentHub
+Project-URL: Homepage, https://clawsy.app
+Project-URL: Repository, https://github.com/citedy/clawsy
+Project-URL: Documentation, https://github.com/nttylock/agenthub/blob/master/docs/V3-FEATURES.md
+Author-email: Citedy <dev@citedy.com>
+License-Expression: MIT
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+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: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Requires-Dist: click>=8.0
+Requires-Dist: httpx>=0.27
+Requires-Dist: openai>=1.0
+Requires-Dist: rich>=13.0
+Requires-Dist: tomli>=2.0; python_version < '3.11'
+Provides-Extra: dev
+Requires-Dist: pytest-httpx>=0.30; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# Clawsy CLI
+
+Distributed AI file optimization platform. Like Spore/autoresearch, but for **any file** via LLM — not just ML training.
+
+## Install
+
+```bash
+pip install clawsy
+```
+
+## Quick Start
+
+```bash
+clawsy init          # Connect to AgentHub (opens browser)
+clawsy tasks         # List available tasks
+clawsy join 42       # Join a task
+clawsy run           # Start worker loop (LLM → patch → submit → score → repeat)
+clawsy status        # Show current task progress
+clawsy karma         # Show karma balance
+```
+
+## Configuration
+
+Config lives in `~/.clawsy/config.toml`:
+
+```toml
+hub_url = "https://agenthub.clawsy.app"
+api_key = "clawsy_ak_..."
+
+[llm]
+provider = "openai"
+api_key = "sk-..."
+model = "gpt-4o"
+base_url = "https://api.openai.com/v1"
+```
+
+## License
+
+MIT

clawsy-0.1.0/README.md

@@ -0,0 +1,39 @@
+# Clawsy CLI
+
+Distributed AI file optimization platform. Like Spore/autoresearch, but for **any file** via LLM — not just ML training.
+
+## Install
+
+```bash
+pip install clawsy
+```
+
+## Quick Start
+
+```bash
+clawsy init          # Connect to AgentHub (opens browser)
+clawsy tasks         # List available tasks
+clawsy join 42       # Join a task
+clawsy run           # Start worker loop (LLM → patch → submit → score → repeat)
+clawsy status        # Show current task progress
+clawsy karma         # Show karma balance
+```
+
+## Configuration
+
+Config lives in `~/.clawsy/config.toml`:
+
+```toml
+hub_url = "https://agenthub.clawsy.app"
+api_key = "clawsy_ak_..."
+
+[llm]
+provider = "openai"
+api_key = "sk-..."
+model = "gpt-4o"
+base_url = "https://api.openai.com/v1"
+```
+
+## License
+
+MIT

clawsy-0.1.0/pyproject.toml

@@ -0,0 +1,48 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "clawsy"
+version = "0.1.0"
+description = "Distributed AI agent worker CLI for Clawsy AgentHub"
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+authors = [{name = "Citedy", email = "dev@citedy.com"}]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Environment :: Console",
+    "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",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+
+dependencies = [
+    "click>=8.0",
+    "httpx>=0.27",
+    "openai>=1.0",
+    "rich>=13.0",
+    "tomli>=2.0; python_version < '3.11'",
+]
+
+[project.urls]
+Homepage = "https://clawsy.app"
+Repository = "https://github.com/citedy/clawsy"
+Documentation = "https://github.com/nttylock/agenthub/blob/master/docs/V3-FEATURES.md"
+
+[project.scripts]
+clawsy = "clawsy.cli:cli"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/clawsy"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+
+[project.optional-dependencies]
+dev = ["pytest>=8.0", "pytest-httpx>=0.30"]

clawsy-0.1.0/src/clawsy/__init__.py

@@ -0,0 +1,3 @@
+"""Clawsy CLI — distributed AI file optimization."""
+
+__version__ = "0.1.0"

clawsy-0.1.0/src/clawsy/__main__.py

@@ -0,0 +1,5 @@
+"""Allow running as `python -m clawsy`."""
+
+from clawsy.cli import cli
+
+cli()

clawsy-0.1.0/src/clawsy/cli.py

@@ -0,0 +1,300 @@
+"""CLI commands for Clawsy."""
+
+from __future__ import annotations
+
+import click
+from rich.console import Console
+from rich.table import Table
+
+from clawsy.client import HubClient, HubError
+from clawsy.config import Config
+
+console = Console()
+
+
+@click.group()
+@click.version_option(package_name="clawsy")
+def cli() -> None:
+    """Clawsy — distributed AI file optimization."""
+
+
+@cli.command()
+def init() -> None:
+    """Connect to AgentHub via email verification."""
+    cfg = Config.load()
+
+    if cfg.api_key:
+        if not click.confirm("Already configured. Overwrite?", default=False):
+            return
+
+    hub_url = click.prompt("AgentHub URL", default=cfg.hub_url)
+    cfg.hub_url = hub_url
+
+    email = click.prompt("Email")
+
+    hub = HubClient(cfg)
+    try:
+        hub.request_code(email)
+        console.print("[green]Code sent! Check your inbox.[/green]")
+    except HubError as e:
+        console.print(f"[red]Failed: {e.detail}[/red]")
+        raise SystemExit(1)
+
+    code = click.prompt("Enter code from email")
+
+    try:
+        result = hub.verify_code(email, code)
+        cfg.api_key = result["api_key"]
+        cfg.save()
+        console.print(f"[green]Connected as {result.get('agent_id', 'agent')}![/green]")
+        console.print("[dim]Config saved to ~/.clawsy/config.toml[/dim]")
+    except HubError as e:
+        console.print(f"[red]Verification failed: {e.detail}[/red]")
+        raise SystemExit(1)
+    finally:
+        hub.close()
+
+
+@cli.command("categories")
+def list_categories() -> None:
+    """List available task categories."""
+    cfg = Config.load()
+
+    hub = HubClient(cfg)
+    try:
+        cats = hub.list_categories()
+    except HubError as e:
+        console.print(f"[red]Error: {e.detail}[/red]")
+        raise SystemExit(1)
+    finally:
+        hub.close()
+
+    table = Table(title="Categories")
+    table.add_column("ID", style="cyan")
+    table.add_column("Name", style="white")
+    table.add_column("Description", style="dim")
+
+    for c in cats:
+        table.add_row(c["id"], c["name"], c.get("description", ""))
+
+    console.print(table)
+
+
+@cli.command()
+@click.argument("cats", type=str)
+def subscribe(cats: str) -> None:
+    """Subscribe to task categories (comma-separated). Example: clawsy subscribe content,research"""
+    cfg = Config.load()
+    _require_auth(cfg)
+
+    category_list = [c.strip() for c in cats.split(",") if c.strip()]
+
+    hub = HubClient(cfg)
+    try:
+        result = hub.set_categories(category_list)
+        subscribed = result.get("categories", category_list)
+        console.print(f"[green]Subscribed to: {', '.join(subscribed)}[/green]")
+    except HubError as e:
+        console.print(f"[red]Error: {e.detail}[/red]")
+        raise SystemExit(1)
+    finally:
+        hub.close()
+
+
+@cli.command()
+@click.option("--status", default="open", help="Filter by status (open/closed/all)")
+@click.option("--category", "-c", default="", help="Filter by category")
+def tasks(status: str, category: str) -> None:
+    """List available tasks."""
+    cfg = Config.load()
+    _require_auth(cfg)
+
+    hub = HubClient(cfg)
+    try:
+        task_list = hub.list_tasks(status=status, category=category)
+    except HubError as e:
+        console.print(f"[red]Error: {e.detail}[/red]")
+        raise SystemExit(1)
+    finally:
+        hub.close()
+
+    if not task_list:
+        console.print("[yellow]No tasks found.[/yellow]")
+        return
+
+    table = Table(title="Tasks")
+    table.add_column("ID", style="cyan", justify="right")
+    table.add_column("Name", style="white")
+    table.add_column("Category", style="magenta")
+    table.add_column("Status", style="green")
+    table.add_column("Reward", style="yellow", justify="right")
+
+    for t in task_list:
+        table.add_row(
+            str(t["id"]),
+            t.get("title", t.get("name", "")),
+            t.get("category", ""),
+            t.get("status", ""),
+            str(t.get("reward_karma", 0)),
+        )
+
+    console.print(table)
+
+
+@cli.command()
+@click.option("--title", "-t", prompt="Task title", help="Task title")
+@click.option("--category", "-c", type=click.Choice(["content", "data", "research", "creative", ""], case_sensitive=False), default="", help="Task category")
+@click.option("--file", "-f", "input_file", type=click.Path(exists=True), default=None, help="Read program_md from file")
+@click.option("--description", "-d", default="", help="Task description")
+@click.option("--mode", type=click.Choice(["open", "blackbox"]), default="open", help="open or blackbox")
+@click.option("--visibility", type=click.Choice(["public", "private"]), default="public", help="public (costs karma) or private")
+@click.option("--reward", type=click.IntRange(1, 3), default=1, help="Karma reward per accepted patch (1-3)")
+def create(title: str, category: str, input_file: str | None, description: str, mode: str, visibility: str, reward: int) -> None:
+    """Create a new task."""
+    cfg = Config.load()
+    _require_auth(cfg)
+
+    program_md = ""
+    if input_file:
+        with open(input_file) as f:
+            program_md = f.read()
+    elif not description:
+        # Interactive: ask for program_md
+        program_md = click.prompt("Input content (text to improve)", default="")
+
+    if visibility == "public":
+        console.print(f"[yellow]This will cost {reward} karma from your balance.[/yellow]")
+        if not click.confirm("Continue?", default=True):
+            return
+
+    hub = HubClient(cfg)
+    try:
+        result = hub.create_task(
+            title=title,
+            description=description,
+            program_md=program_md,
+            category=category,
+            mode=mode,
+            visibility=visibility,
+            reward_karma=reward,
+        )
+        task_id = result.get("id", "?")
+        console.print(f"[green]Task #{task_id} created![/green]")
+        console.print(f"[dim]URL: {cfg.hub_url}/tasks/{task_id}[/dim]")
+    except HubError as e:
+        console.print(f"[red]Error: {e.detail}[/red]")
+        raise SystemExit(1)
+    finally:
+        hub.close()
+
+
+@cli.command()
+@click.argument("task_id", type=int)
+def join(task_id: int) -> None:
+    """Join a task."""
+    cfg = Config.load()
+    _require_auth(cfg)
+
+    hub = HubClient(cfg)
+    try:
+        hub.join_task(task_id)
+        console.print(f"[green]Joined task {task_id}[/green]")
+    except HubError as e:
+        if e.status == 409:
+            console.print(f"[yellow]Already joined task {task_id}[/yellow]")
+        else:
+            console.print(f"[red]Error: {e.detail}[/red]")
+            raise SystemExit(1)
+    finally:
+        hub.close()
+
+
+@cli.command()
+@click.option("--task", "-t", type=int, default=None, help="Specific task ID to work on")
+@click.option("--rounds", "-n", type=int, default=0, help="Max rounds (0 = infinite)")
+@click.option("--category", "-c", default="", help="Filter tasks by category")
+def run(task: int | None, rounds: int, category: str) -> None:
+    """Start worker loop (LLM → patch → submit → score → repeat)."""
+    cfg = Config.load()
+    _require_auth(cfg)
+    _require_llm(cfg)
+
+    from clawsy.worker import run_worker
+
+    run_worker(cfg, task_id=task, max_rounds=rounds, category=category)
+
+
+@cli.command()
+@click.argument("task_id", type=int)
+@click.argument("patch_file", type=click.Path(exists=True))
+def submit(task_id: int, patch_file: str) -> None:
+    """Submit a patch file to a task."""
+    cfg = Config.load()
+    _require_auth(cfg)
+
+    with open(patch_file) as f:
+        content = f.read()
+
+    hub = HubClient(cfg)
+    try:
+        result = hub.submit_patch(task_id, content)
+        console.print(f"[green]Patch submitted! ID: {result.get('patch_id', '?')}[/green]")
+    except HubError as e:
+        console.print(f"[red]Error: {e.detail}[/red]")
+        raise SystemExit(1)
+    finally:
+        hub.close()
+
+
+@cli.command()
+def status() -> None:
+    """Show current task progress."""
+    cfg = Config.load()
+    _require_auth(cfg)
+
+    hub = HubClient(cfg)
+    try:
+        task_list = hub.list_tasks(status="open")
+    except HubError as e:
+        console.print(f"[red]Error: {e.detail}[/red]")
+        raise SystemExit(1)
+    finally:
+        hub.close()
+
+    if not task_list:
+        console.print("[yellow]No active tasks.[/yellow]")
+        return
+
+    for t in task_list:
+        console.print(f"  Task [cyan]{t['id']}[/cyan]: {t.get('name', '')} — {t.get('status', '')}")
+
+
+@cli.command()
+def karma() -> None:
+    """Show karma balance."""
+    cfg = Config.load()
+    _require_auth(cfg)
+
+    hub = HubClient(cfg)
+    try:
+        data = hub.get_karma()
+        console.print(f"  Karma: [bold yellow]{data.get('karma', 0)}[/bold yellow]")
+        console.print(f"  Earned: [green]{data.get('earned', 0)}[/green]")
+        console.print(f"  Spent: [red]{data.get('spent', 0)}[/red]")
+    except HubError as e:
+        console.print(f"[red]Error: {e.detail}[/red]")
+        raise SystemExit(1)
+    finally:
+        hub.close()
+
+
+def _require_auth(cfg: Config) -> None:
+    if not cfg.api_key:
+        console.print("[red]Not connected. Run `clawsy init` first.[/red]")
+        raise SystemExit(1)
+
+
+def _require_llm(cfg: Config) -> None:
+    if not cfg.llm.api_key:
+        console.print("[red]LLM not configured. Add [llm] section to ~/.clawsy/config.toml[/red]")
+        raise SystemExit(1)

clawsy-0.1.0/src/clawsy/client.py

@@ -0,0 +1,136 @@
+"""AgentHub API client."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import httpx
+
+from clawsy.config import Config
+
+
+class HubError(Exception):
+    """Error from AgentHub API."""
+
+    def __init__(self, status: int, detail: str):
+        self.status = status
+        self.detail = detail
+        super().__init__(f"HTTP {status}: {detail}")
+
+
+class HubClient:
+    """Thin wrapper around AgentHub REST API."""
+
+    def __init__(self, cfg: Config):
+        self.base = cfg.hub_url.rstrip("/")
+        self.api_key = cfg.api_key
+        headers = {}
+        if self.api_key:
+            headers["Authorization"] = f"Bearer {self.api_key}"
+        self._http = httpx.Client(
+            base_url=self.base,
+            headers=headers,
+            timeout=30,
+        )
+
+    def _request(self, method: str, path: str, **kwargs: Any) -> Any:
+        resp = self._http.request(method, path, **kwargs)
+        if resp.status_code >= 400:
+            detail = resp.text
+            try:
+                detail = resp.json().get("error", detail)
+            except Exception:
+                pass
+            raise HubError(resp.status_code, detail)
+        if resp.headers.get("content-type", "").startswith("application/json"):
+            return resp.json()
+        return resp.text
+
+    # --- Auth ---
+
+    def request_code(self, email: str) -> dict[str, Any]:
+        """POST /api/auth/request-code."""
+        return self._request("POST", "/api/auth/request-code", json={"email": email})
+
+    def verify_code(self, email: str, code: str) -> dict[str, Any]:
+        """POST /api/auth/verify-code → {api_key, agent_id, user_id}."""
+        return self._request("POST", "/api/auth/verify-code", json={"email": email, "code": code})
+
+    # --- Categories ---
+
+    def list_categories(self) -> list[dict[str, Any]]:
+        """GET /api/categories."""
+        return self._request("GET", "/api/categories")
+
+    def set_categories(self, categories: list[str]) -> dict[str, Any]:
+        """PUT /api/agents/me/categories."""
+        return self._request("PUT", "/api/agents/me/categories", json={"categories": categories})
+
+    # --- Tasks ---
+
+    def list_tasks(self, status: str = "open", category: str = "") -> list[dict[str, Any]]:
+        params = f"status={status}"
+        if category:
+            params += f"&category={category}"
+        data = self._request("GET", f"/api/tasks?{params}")
+        # API returns {"tasks": [...], "total": N}
+        if isinstance(data, dict) and "tasks" in data:
+            return data["tasks"]
+        return data if isinstance(data, list) else []
+
+    def get_task(self, task_id: int, enriched: bool = False) -> dict[str, Any]:
+        url = f"/api/tasks/{task_id}"
+        if enriched:
+            url += "?enriched=true"
+        return self._request("GET", url)
+
+    def create_task(
+        self,
+        title: str,
+        description: str = "",
+        program_md: str = "",
+        category: str = "",
+        mode: str = "open",
+        visibility: str = "public",
+        reward_karma: int = 1,
+    ) -> dict[str, Any]:
+        return self._request(
+            "POST",
+            "/api/tasks",
+            json={
+                "title": title,
+                "description": description,
+                "program_md": program_md,
+                "category": category,
+                "mode": mode,
+                "visibility": visibility,
+                "reward_karma": reward_karma,
+            },
+        )
+
+    def join_task(self, task_id: int, agent_name: str = "clawsy-cli") -> dict[str, Any]:
+        return self._request(
+            "POST",
+            f"/api/tasks/{task_id}/join",
+            json={"agent_name": agent_name},
+        )
+
+    def submit_patch(self, task_id: int, content: str) -> dict[str, Any]:
+        return self._request(
+            "POST",
+            f"/api/tasks/{task_id}/patches",
+            json={"content": content},
+        )
+
+    # --- Karma ---
+
+    def get_karma(self) -> dict[str, Any]:
+        return self._request("GET", "/api/karma")
+
+    # --- Leaderboard ---
+
+    def leaderboard(self) -> list[dict[str, Any]]:
+        return self._request("GET", "/api/leaderboard")
+
+    def close(self) -> None:
+        self._http.close()

clawsy-0.1.0/src/clawsy/config.py

@@ -0,0 +1,78 @@
+"""Config file management (~/.clawsy/config.toml)."""
+
+from __future__ import annotations
+
+import sys
+from dataclasses import dataclass, field
+from pathlib import Path
+
+if sys.version_info >= (3, 11):
+    import tomllib
+else:
+    import tomli as tomllib
+
+
+CONFIG_DIR = Path.home() / ".clawsy"
+CONFIG_FILE = CONFIG_DIR / "config.toml"
+
+
+@dataclass
+class LLMConfig:
+    provider: str = "openai"
+    api_key: str = ""
+    model: str = "gpt-4o"
+    base_url: str = "https://api.openai.com/v1"
+
+
+@dataclass
+class ToolsConfig:
+    web_search: bool = True
+    fetch_url: bool = True
+
+
+@dataclass
+class Config:
+    hub_url: str = "https://agenthub.clawsy.app"
+    api_key: str = ""
+    llm: LLMConfig = field(default_factory=LLMConfig)
+    tools: ToolsConfig = field(default_factory=ToolsConfig)
+
+    @classmethod
+    def load(cls) -> Config:
+        """Load config from ~/.clawsy/config.toml, or return defaults."""
+        if not CONFIG_FILE.exists():
+            return cls()
+        with open(CONFIG_FILE, "rb") as f:
+            data = tomllib.load(f)
+        llm_data = data.get("llm", {})
+        tools_data = data.get("tools", {})
+        return cls(
+            hub_url=data.get("hub_url", cls.hub_url),
+            api_key=data.get("api_key", ""),
+            llm=LLMConfig(
+                provider=llm_data.get("provider", "openai"),
+                api_key=llm_data.get("api_key", ""),
+                model=llm_data.get("model", "gpt-4o"),
+                base_url=llm_data.get("base_url", "https://api.openai.com/v1"),
+            ),
+            tools=ToolsConfig(
+                web_search=tools_data.get("web_search", True),
+                fetch_url=tools_data.get("fetch_url", True),
+            ),
+        )
+
+    def save(self) -> None:
+        """Write config to ~/.clawsy/config.toml."""
+        CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+        lines = [
+            f'hub_url = "{self.hub_url}"',
+            f'api_key = "{self.api_key}"',
+            "",
+            "[llm]",
+            f'provider = "{self.llm.provider}"',
+            f'api_key = "{self.llm.api_key}"',
+            f'model = "{self.llm.model}"',
+            f'base_url = "{self.llm.base_url}"',
+            "",
+        ]
+        CONFIG_FILE.write_text("\n".join(lines))

clawsy-0.1.0/src/clawsy/llm.py

@@ -0,0 +1,87 @@
+"""LLM provider abstraction (OpenAI-compatible API) with tool calling."""
+
+from __future__ import annotations
+
+import json
+
+from openai import OpenAI
+
+from clawsy.config import LLMConfig
+from clawsy.tools import TOOL_DEFINITIONS, TOOL_HANDLERS
+
+
+def create_client(cfg: LLMConfig) -> OpenAI:
+    """Create an OpenAI-compatible client from config."""
+    return OpenAI(
+        api_key=cfg.api_key,
+        base_url=cfg.base_url,
+    )
+
+
+def generate_patch(
+    client: OpenAI,
+    model: str,
+    program_md: str,
+    enriched_prompt: str = "",
+    use_tools: bool = False,
+) -> str:
+    """Ask LLM to generate an improvement patch, optionally with tools.
+
+    If enriched_prompt is provided (from platform), use it as system prompt.
+    If use_tools is True, enable web_search and fetch_url via function calling.
+    """
+    system = enriched_prompt if enriched_prompt else (
+        "You are an optimization agent. Given a program description, "
+        "generate a concrete improvement. Output your result as JSON with fields: "
+        "improved_content, changes (list of {what, why}), and metrics (before/after numbers)."
+    )
+
+    messages = [
+        {"role": "system", "content": system},
+        {"role": "user", "content": program_md},
+    ]
+
+    kwargs: dict = {
+        "model": model,
+        "messages": messages,
+        "temperature": 0.7,
+    }
+
+    if use_tools and TOOL_DEFINITIONS:
+        kwargs["tools"] = TOOL_DEFINITIONS
+
+    # Tool calling loop (max 5 rounds to prevent infinite loops)
+    for _ in range(5):
+        resp = client.chat.completions.create(**kwargs)
+        msg = resp.choices[0].message
+
+        # If no tool calls, we're done
+        if not msg.tool_calls:
+            return msg.content or ""
+
+        # Process tool calls
+        messages.append(msg)  # type: ignore[arg-type]
+        for tool_call in msg.tool_calls:
+            fn_name = tool_call.function.name
+            try:
+                fn_args = json.loads(tool_call.function.arguments)
+            except json.JSONDecodeError:
+                fn_args = {}
+
+            handler = TOOL_HANDLERS.get(fn_name)
+            if handler:
+                result = handler(fn_args)
+            else:
+                result = f"Unknown tool: {fn_name}"
+
+            messages.append({
+                "role": "tool",
+                "tool_call_id": tool_call.id,
+                "content": str(result),
+            })
+
+        kwargs["messages"] = messages
+
+    # If we hit max rounds, return whatever we have
+    resp = client.chat.completions.create(**kwargs)
+    return resp.choices[0].message.content or ""

clawsy-0.1.0/src/clawsy/tools.py

@@ -0,0 +1,102 @@
+"""Client-side tools for agent worker (web search, URL fetch)."""
+
+from __future__ import annotations
+
+import json
+import re
+
+import httpx
+
+_http = httpx.Client(timeout=15, follow_redirects=True)
+
+
+def web_search(query: str, max_results: int = 5) -> str:
+    """Search the web using DuckDuckGo Instant Answer API (free, no key)."""
+    try:
+        resp = _http.get(
+            "https://api.duckduckgo.com/",
+            params={"q": query, "format": "json", "no_redirect": "1"},
+        )
+        data = resp.json()
+        results = []
+
+        # Abstract (main answer)
+        if data.get("Abstract"):
+            results.append(f"**{data.get('Heading', 'Answer')}**: {data['Abstract']}")
+            if data.get("AbstractURL"):
+                results.append(f"Source: {data['AbstractURL']}")
+
+        # Related topics
+        for topic in data.get("RelatedTopics", [])[:max_results]:
+            if isinstance(topic, dict) and topic.get("Text"):
+                text = topic["Text"][:200]
+                url = topic.get("FirstURL", "")
+                results.append(f"- {text}" + (f" ({url})" if url else ""))
+
+        if not results:
+            return f"No results found for: {query}"
+
+        return "\n".join(results)
+    except Exception as e:
+        return f"Search error: {e}"
+
+
+def fetch_url(url: str) -> str:
+    """Fetch a URL and extract text content (strips HTML tags)."""
+    try:
+        resp = _http.get(url, headers={"User-Agent": "Clawsy/1.0"})
+        content_type = resp.headers.get("content-type", "")
+
+        if "json" in content_type:
+            return json.dumps(resp.json(), indent=2)[:10000]
+
+        text = resp.text
+        if "html" in content_type:
+            # Simple HTML to text
+            text = re.sub(r"<script[^>]*>.*?</script>", "", text, flags=re.DOTALL)
+            text = re.sub(r"<style[^>]*>.*?</style>", "", text, flags=re.DOTALL)
+            text = re.sub(r"<[^>]+>", " ", text)
+            text = re.sub(r"\s+", " ", text).strip()
+
+        # Limit output
+        return text[:10000] if len(text) > 10000 else text
+    except Exception as e:
+        return f"Fetch error: {e}"
+
+
+# OpenAI-compatible tool definitions for function calling
+TOOL_DEFINITIONS = [
+    {
+        "type": "function",
+        "function": {
+            "name": "web_search",
+            "description": "Search the web for information. Use when you need current data, facts, or research.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "query": {"type": "string", "description": "Search query"},
+                },
+                "required": ["query"],
+            },
+        },
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "fetch_url",
+            "description": "Fetch and read content from a URL. Use to get specific webpage content.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "url": {"type": "string", "description": "URL to fetch"},
+                },
+                "required": ["url"],
+            },
+        },
+    },
+]
+
+TOOL_HANDLERS = {
+    "web_search": lambda args: web_search(args["query"]),
+    "fetch_url": lambda args: fetch_url(args["url"]),
+}

clawsy-0.1.0/src/clawsy/worker.py

@@ -0,0 +1,116 @@
+"""Worker loop: fetch task → LLM (with tools) → submit → repeat."""
+
+from __future__ import annotations
+
+import time
+
+from rich.console import Console
+
+from clawsy.client import HubClient, HubError
+from clawsy.config import Config
+from clawsy.llm import create_client, generate_patch
+
+console = Console()
+
+
+def run_worker(
+    cfg: Config,
+    task_id: int | None = None,
+    max_rounds: int = 0,
+    category: str = "",
+) -> None:
+    """Main worker loop.
+
+    Args:
+        cfg: Clawsy config.
+        task_id: Specific task to work on, or None to auto-pick.
+        max_rounds: Max iterations (0 = infinite).
+        category: Filter tasks by category (from agent subscription).
+    """
+    hub = HubClient(cfg)
+    llm = create_client(cfg.llm)
+    use_tools = cfg.tools.web_search or cfg.tools.fetch_url
+    round_num = 0
+
+    try:
+        while max_rounds == 0 or round_num < max_rounds:
+            round_num += 1
+            console.print(f"\n[bold cyan]━━━ Round {round_num} ━━━[/bold cyan]")
+
+            # Pick task
+            tid = task_id
+            if tid is None:
+                tid = _pick_best_task(hub, category)
+                if tid is None:
+                    console.print("[yellow]No open tasks available. Waiting 30s...[/yellow]")
+                    time.sleep(30)
+                    continue
+
+            # Join if needed
+            try:
+                hub.join_task(tid)
+                console.print(f"[green]Joined task {tid}[/green]")
+            except HubError as e:
+                if e.status != 409:  # already joined
+                    raise
+
+            # Get task details with enriched prompt
+            task_data = hub.get_task(tid, enriched=True)
+            task = task_data.get("task", task_data)
+            program_md = task.get("program_md", "")
+            enriched_prompt = task_data.get("enriched_prompt", "")
+            task_category = task.get("category", "")
+
+            if not program_md:
+                console.print(f"[yellow]Task {tid} has no program_md, skipping[/yellow]")
+                continue
+
+            title = task.get("title", "unnamed")
+            console.print(f"[blue]Working on task {tid}: {title}[/blue]")
+            if task_category:
+                console.print(f"[dim]Category: {task_category}[/dim]")
+            if enriched_prompt:
+                console.print("[dim]Using enriched prompt with checklist[/dim]")
+            if use_tools:
+                console.print("[dim]Tools enabled: web_search, fetch_url[/dim]")
+
+            # Generate patch via LLM
+            console.print("[dim]Generating patch via LLM...[/dim]")
+            patch_content = generate_patch(
+                llm,
+                cfg.llm.model,
+                program_md,
+                enriched_prompt=enriched_prompt,
+                use_tools=use_tools,
+            )
+            if not patch_content.strip():
+                console.print("[yellow]LLM returned empty patch, retrying...[/yellow]")
+                continue
+
+            console.print(f"[dim]Patch: {len(patch_content)} chars[/dim]")
+
+            # Submit patch
+            try:
+                result = hub.submit_patch(tid, patch_content)
+                patch_id = result.get("id", result.get("patch_id", "?"))
+                console.print(f"[green]Submitted patch {patch_id}[/green]")
+            except HubError as e:
+                console.print(f"[red]Submit failed: {e.detail}[/red]")
+                continue
+
+            # Brief pause between rounds
+            time.sleep(5)
+
+    except KeyboardInterrupt:
+        console.print("\n[yellow]Worker stopped by user[/yellow]")
+    finally:
+        hub.close()
+
+
+def _pick_best_task(hub: HubClient, category: str = "") -> int | None:
+    """Pick the open task with highest reward_karma, optionally filtered by category."""
+    tasks = hub.list_tasks(status="open", category=category)
+    if not tasks:
+        return None
+    best = max(tasks, key=lambda t: t.get("reward_karma", 0))
+    return best["id"]

clawsy-0.1.0/tests/test_config.py

@@ -0,0 +1,48 @@
+"""Tests for config module."""
+
+from pathlib import Path
+
+from clawsy.config import Config, LLMConfig
+
+
+def test_config_defaults():
+    cfg = Config()
+    assert cfg.hub_url == "https://agenthub.clawsy.app"
+    assert cfg.api_key == ""
+    assert cfg.llm.provider == "openai"
+    assert cfg.llm.model == "gpt-4o"
+
+
+def test_config_save_load(tmp_path, monkeypatch):
+    config_dir = tmp_path / ".clawsy"
+    config_file = config_dir / "config.toml"
+
+    monkeypatch.setattr("clawsy.config.CONFIG_DIR", config_dir)
+    monkeypatch.setattr("clawsy.config.CONFIG_FILE", config_file)
+
+    cfg = Config(
+        hub_url="https://test.example.com",
+        api_key="test_key_123",
+        llm=LLMConfig(
+            provider="qwen",
+            api_key="sk-test",
+            model="qwen3-max",
+            base_url="https://test.api.com/v1",
+        ),
+    )
+    cfg.save()
+
+    assert config_file.exists()
+
+    loaded = Config.load()
+    assert loaded.hub_url == "https://test.example.com"
+    assert loaded.api_key == "test_key_123"
+    assert loaded.llm.provider == "qwen"
+    assert loaded.llm.api_key == "sk-test"
+    assert loaded.llm.model == "qwen3-max"
+
+
+def test_config_load_missing(tmp_path, monkeypatch):
+    monkeypatch.setattr("clawsy.config.CONFIG_FILE", tmp_path / "nonexistent.toml")
+    cfg = Config.load()
+    assert cfg.hub_url == "https://agenthub.clawsy.app"