llmcode-cli 1.0.0__py3-none-any.whl

llm_code/tools/search_backends/duckduckgo.py

@@ -0,0 +1,129 @@
+"""DuckDuckGo Lite search backend."""
+from __future__ import annotations
+
+import time
+from html.parser import HTMLParser
+
+import httpx
+
+from llm_code.tools.search_backends import SearchResult
+
+_DDG_LITE_URL = "https://lite.duckduckgo.com/lite/"
+_RATE_LIMIT_SECONDS = 1.0
+
+
+class _DDGLiteParser(HTMLParser):
+    """Parse DuckDuckGo Lite HTML to extract search results."""
+
+    def __init__(self) -> None:
+        super().__init__()
+        self._results: list[dict[str, str]] = []
+        self._in_title_link = False
+        self._in_snippet = False
+        self._current_url = ""
+        self._current_title = ""
+        self._snippet_depth = 0
+
+    def handle_starttag(self, tag: str, attrs: list[tuple[str, str | None]]) -> None:
+        attr_dict = dict(attrs)
+        classes = attr_dict.get("class", "") or ""
+
+        if tag == "a" and "result__a" in classes:
+            self._in_title_link = True
+            self._current_url = attr_dict.get("href", "")
+            self._current_title = ""
+
+        if tag == "div" and "result__snippet" in classes:
+            self._in_snippet = True
+            self._snippet_depth = 1
+            self._current_snippet = ""
+
+        if self._in_snippet and tag != "div":
+            pass  # track inner tags
+
+    def handle_endtag(self, tag: str) -> None:
+        if self._in_title_link and tag == "a":
+            self._in_title_link = False
+
+        if self._in_snippet and tag == "div":
+            self._in_snippet = False
+            # Save result when snippet ends
+            if self._current_url and self._current_title:
+                self._results.append({
+                    "title": self._current_title.strip(),
+                    "url": self._current_url,
+                    "snippet": getattr(self, "_current_snippet", "").strip(),
+                })
+
+    def handle_data(self, data: str) -> None:
+        if self._in_title_link:
+            self._current_title += data
+        if self._in_snippet:
+            self._current_snippet += data
+
+    def get_results(self) -> list[dict[str, str]]:
+        return self._results
+
+
+class DuckDuckGoBackend:
+    """Search backend using DuckDuckGo Lite."""
+
+    def __init__(self) -> None:
+        self._last_request_time: float = 0.0
+
+    @property
+    def name(self) -> str:
+        return "duckduckgo"
+
+    def _rate_limit(self) -> None:
+        """Enforce 1-second rate limit between requests."""
+        elapsed = time.monotonic() - self._last_request_time
+        if elapsed < _RATE_LIMIT_SECONDS:
+            time.sleep(_RATE_LIMIT_SECONDS - elapsed)
+        self._last_request_time = time.monotonic()
+
+    def search(self, query: str, *, max_results: int = 10) -> tuple[SearchResult, ...]:
+        """Search DuckDuckGo Lite and return results.
+
+        Args:
+            query: Search query string.
+            max_results: Maximum number of results to return.
+
+        Returns:
+            Tuple of SearchResult, or empty tuple on error.
+        """
+        self._rate_limit()
+
+        try:
+            response = httpx.get(
+                _DDG_LITE_URL,
+                params={"q": query},
+                headers={
+                    "User-Agent": (
+                        "Mozilla/5.0 (compatible; llm-code/1.0; "
+                        "+https://github.com/llm-code)"
+                    )
+                },
+                timeout=10.0,
+                follow_redirects=True,
+            )
+        except httpx.RequestError:
+            return ()
+
+        if response.status_code != 200:
+            return ()
+
+        parser = _DDGLiteParser()
+        parser.feed(response.text)
+        raw = parser.get_results()
+
+        results = tuple(
+            SearchResult(
+                title=r["title"],
+                url=r["url"],
+                snippet=r["snippet"],
+            )
+            for r in raw[:max_results]
+            if r.get("title") and r.get("url")
+        )
+        return results

llm_code/tools/search_backends/searxng.py

@@ -0,0 +1,71 @@
+"""SearXNG search backend."""
+from __future__ import annotations
+
+import httpx
+
+from llm_code.tools.search_backends import SearchResult
+
+
+class SearXNGBackend:
+    """Search backend using a self-hosted SearXNG instance."""
+
+    def __init__(self, base_url: str) -> None:
+        """Initialize with SearXNG instance base URL.
+
+        Args:
+            base_url: Base URL of SearXNG instance (e.g. http://localhost:8080).
+
+        Raises:
+            ValueError: If base_url is empty or whitespace.
+        """
+        if not base_url or not base_url.strip():
+            raise ValueError("base_url must not be empty")
+        self._base_url = base_url.rstrip("/")
+
+    @property
+    def name(self) -> str:
+        return "searxng"
+
+    def search(self, query: str, *, max_results: int = 10) -> tuple[SearchResult, ...]:
+        """Search via SearXNG JSON API.
+
+        Args:
+            query: Search query string.
+            max_results: Maximum number of results to return.
+
+        Returns:
+            Tuple of SearchResult, or empty tuple on error.
+        """
+        search_url = f"{self._base_url}/search"
+        try:
+            response = httpx.get(
+                search_url,
+                params={
+                    "q": query,
+                    "format": "json",
+                    "pageno": 1,
+                },
+                timeout=15.0,
+            )
+        except httpx.RequestError:
+            return ()
+
+        if response.status_code != 200:
+            return ()
+
+        try:
+            data = response.json()
+        except Exception:
+            return ()
+
+        raw_results = data.get("results", [])
+        results = tuple(
+            SearchResult(
+                title=r.get("title", ""),
+                url=r.get("url", ""),
+                snippet=r.get("content", ""),
+            )
+            for r in raw_results[:max_results]
+            if r.get("url")
+        )
+        return results

llm_code/tools/search_backends/tavily.py

@@ -0,0 +1,73 @@
+"""Tavily search backend."""
+from __future__ import annotations
+
+import httpx
+
+from llm_code.tools.search_backends import SearchResult
+
+_TAVILY_SEARCH_URL = "https://api.tavily.com/search"
+
+
+class TavilyBackend:
+    """Search backend using Tavily API."""
+
+    def __init__(self, api_key: str) -> None:
+        """Initialize with Tavily API key.
+
+        Args:
+            api_key: Tavily API key.
+
+        Raises:
+            ValueError: If api_key is empty or whitespace.
+        """
+        if not api_key or not api_key.strip():
+            raise ValueError("api_key must not be empty")
+        self._api_key = api_key
+
+    @property
+    def name(self) -> str:
+        return "tavily"
+
+    def search(self, query: str, *, max_results: int = 10) -> tuple[SearchResult, ...]:
+        """Search via Tavily API.
+
+        Args:
+            query: Search query string.
+            max_results: Maximum number of results to return.
+
+        Returns:
+            Tuple of SearchResult, or empty tuple on error.
+        """
+        try:
+            response = httpx.post(
+                _TAVILY_SEARCH_URL,
+                json={
+                    "api_key": self._api_key,
+                    "query": query,
+                    "max_results": max_results,
+                    "search_depth": "basic",
+                },
+                timeout=15.0,
+            )
+        except httpx.RequestError:
+            return ()
+
+        if response.status_code != 200:
+            return ()
+
+        try:
+            data = response.json()
+        except Exception:
+            return ()
+
+        raw_results = data.get("results", [])
+        results = tuple(
+            SearchResult(
+                title=r.get("title", ""),
+                url=r.get("url", ""),
+                snippet=r.get("content", ""),
+            )
+            for r in raw_results[:max_results]
+            if r.get("url")
+        )
+        return results

llm_code/tools/swarm_create.py

@@ -0,0 +1,109 @@
+"""SwarmCreateTool — spawn a new swarm worker agent."""
+from __future__ import annotations
+
+import asyncio
+
+from pydantic import BaseModel
+
+from llm_code.swarm.manager import SwarmManager
+from llm_code.tools.base import PermissionLevel, Tool, ToolResult
+
+
+class SwarmCreateInput(BaseModel):
+    role: str
+    task: str
+    backend: str = "auto"
+    model: str | None = None
+
+
+class SwarmCreateTool(Tool):
+    def __init__(self, manager: SwarmManager) -> None:
+        self._manager = manager
+
+    @property
+    def name(self) -> str:
+        return "swarm_create"
+
+    @property
+    def description(self) -> str:
+        return (
+            "Spawn a new swarm worker agent with a given role and task. "
+            "The worker runs as a separate llm-code --lite process. "
+            "Backend: 'auto' (tmux if available, else subprocess), 'tmux', or 'subprocess'."
+        )
+
+    @property
+    def input_schema(self) -> dict:
+        return {
+            "type": "object",
+            "properties": {
+                "role": {
+                    "type": "string",
+                    "description": "Role of the worker (e.g. 'security reviewer', 'test writer')",
+                },
+                "task": {
+                    "type": "string",
+                    "description": "Task description for the worker to execute",
+                },
+                "backend": {
+                    "type": "string",
+                    "enum": ["auto", "tmux", "subprocess"],
+                    "description": "Backend to use (default: auto)",
+                    "default": "auto",
+                },
+                "model": {
+                    "type": "string",
+                    "description": (
+                        "Override the LLM model for this specific swarm member. "
+                        "When omitted, the model is resolved via the config fallback chain: "
+                        "role_models -> model_routing.sub_agent -> global model."
+                    ),
+                },
+            },
+            "required": ["role", "task"],
+        }
+
+    @property
+    def required_permission(self) -> PermissionLevel:
+        return PermissionLevel.FULL_ACCESS
+
+    @property
+    def input_model(self) -> type[SwarmCreateInput]:
+        return SwarmCreateInput
+
+    def execute(self, args: dict) -> ToolResult:
+        role = args["role"]
+        task = args["task"]
+        backend = args.get("backend", "auto")
+        model = args.get("model")
+
+        try:
+            try:
+                asyncio.get_running_loop()
+                running = True
+            except RuntimeError:
+                running = False
+
+            if running:
+                import concurrent.futures
+                with concurrent.futures.ThreadPoolExecutor() as pool:
+                    member = pool.submit(
+                        asyncio.run,
+                        self._manager.create_member(role=role, task=task, backend=backend, model=model),
+                    ).result()
+            else:
+                member = asyncio.run(
+                    self._manager.create_member(role=role, task=task, backend=backend, model=model)
+                )
+        except ValueError as exc:
+            return ToolResult(output=str(exc), is_error=True)
+
+        return ToolResult(
+            output=(
+                f"Created swarm member {member.id}\n"
+                f"  Role: {member.role}\n"
+                f"  Task: {member.task}\n"
+                f"  Backend: {member.backend}\n"
+                f"  PID: {member.pid}"
+            )
+        )

llm_code/tools/swarm_delete.py

@@ -0,0 +1,95 @@
+"""SwarmDeleteTool — stop one or all swarm members."""
+from __future__ import annotations
+
+import asyncio
+
+from pydantic import BaseModel
+
+from llm_code.swarm.manager import SwarmManager
+from llm_code.tools.base import PermissionLevel, Tool, ToolResult
+
+
+class SwarmDeleteInput(BaseModel):
+    action: str = "stop"        # "stop" | "stop_all"
+    member_id: str = ""
+
+
+class SwarmDeleteTool(Tool):
+    def __init__(self, manager: SwarmManager) -> None:
+        self._manager = manager
+
+    @property
+    def name(self) -> str:
+        return "swarm_delete"
+
+    @property
+    def description(self) -> str:
+        return (
+            "Stop one or all swarm members. "
+            "action='stop' + member_id to stop a single member. "
+            "action='stop_all' to stop all members."
+        )
+
+    @property
+    def input_schema(self) -> dict:
+        return {
+            "type": "object",
+            "properties": {
+                "action": {
+                    "type": "string",
+                    "enum": ["stop", "stop_all"],
+                    "description": "stop (one) or stop_all",
+                    "default": "stop",
+                },
+                "member_id": {
+                    "type": "string",
+                    "description": "ID of the member to stop (for action=stop)",
+                },
+            },
+            "required": ["action"],
+        }
+
+    @property
+    def required_permission(self) -> PermissionLevel:
+        return PermissionLevel.FULL_ACCESS
+
+    @property
+    def input_model(self) -> type[SwarmDeleteInput]:
+        return SwarmDeleteInput
+
+    def execute(self, args: dict) -> ToolResult:
+        action = args.get("action", "stop")
+
+        try:
+            running = False
+            try:
+                asyncio.get_running_loop()
+                running = True
+            except RuntimeError:
+                pass
+
+            if action == "stop_all":
+                if running:
+                    import concurrent.futures
+                    with concurrent.futures.ThreadPoolExecutor() as pool:
+                        pool.submit(asyncio.run, self._manager.stop_all()).result()
+                else:
+                    asyncio.run(self._manager.stop_all())
+                return ToolResult(output="All swarm members stopped.")
+
+            member_id = args.get("member_id", "")
+            if not member_id:
+                return ToolResult(output="member_id is required for action=stop", is_error=True)
+
+            if running:
+                import concurrent.futures
+                with concurrent.futures.ThreadPoolExecutor() as pool:
+                    pool.submit(asyncio.run, self._manager.stop_member(member_id)).result()
+            else:
+                asyncio.run(self._manager.stop_member(member_id))
+            return ToolResult(output=f"Stopped swarm member {member_id}")
+
+        except KeyError:
+            return ToolResult(output=f"No swarm member with id '{args.get('member_id')}'", is_error=True)
+        except Exception as exc:
+            return ToolResult(output=f"Error: {exc}", is_error=True)

llm_code/tools/swarm_list.py

@@ -0,0 +1,44 @@
+"""SwarmListTool — list all active swarm members."""
+from __future__ import annotations
+
+from llm_code.swarm.manager import SwarmManager
+from llm_code.tools.base import PermissionLevel, Tool, ToolResult
+
+
+class SwarmListTool(Tool):
+    def __init__(self, manager: SwarmManager) -> None:
+        self._manager = manager
+
+    @property
+    def name(self) -> str:
+        return "swarm_list"
+
+    @property
+    def description(self) -> str:
+        return "List all active swarm worker agents with their roles, tasks, and status."
+
+    @property
+    def input_schema(self) -> dict:
+        return {"type": "object", "properties": {}}
+
+    @property
+    def required_permission(self) -> PermissionLevel:
+        return PermissionLevel.READ_ONLY
+
+    def is_read_only(self, args: dict) -> bool:
+        return True
+
+    def is_concurrency_safe(self, args: dict) -> bool:
+        return True
+
+    def execute(self, args: dict) -> ToolResult:
+        members = self._manager.list_members()
+        if not members:
+            return ToolResult(output="No swarm members active.")
+        lines = []
+        for m in members:
+            lines.append(
+                f"- {m.id} | role={m.role} | task={m.task[:50]} | "
+                f"backend={m.backend} | pid={m.pid} | status={m.status.value}"
+            )
+        return ToolResult(output="\n".join(lines))

llm_code/tools/swarm_message.py

@@ -0,0 +1,109 @@
+"""SwarmMessageTool — send and receive messages between swarm members."""
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+from llm_code.swarm.manager import SwarmManager
+from llm_code.tools.base import PermissionLevel, Tool, ToolResult
+
+
+class SwarmMessageInput(BaseModel):
+    action: str       # "send" | "receive" | "broadcast" | "pending"
+    from_id: str = ""
+    to_id: str = ""
+    text: str = ""
+    member_ids: list[str] = []
+
+
+class SwarmMessageTool(Tool):
+    def __init__(self, manager: SwarmManager) -> None:
+        self._manager = manager
+
+    @property
+    def name(self) -> str:
+        return "swarm_message"
+
+    @property
+    def description(self) -> str:
+        return (
+            "Send and receive messages between swarm members. "
+            "Actions: 'send' (from_id, to_id, text), "
+            "'receive' (from_id, to_id), "
+            "'broadcast' (from_id, member_ids, text), "
+            "'pending' (to_id — show unread messages for a member)."
+        )
+
+    @property
+    def input_schema(self) -> dict:
+        return {
+            "type": "object",
+            "properties": {
+                "action": {
+                    "type": "string",
+                    "enum": ["send", "receive", "broadcast", "pending"],
+                    "description": "Message action to perform",
+                },
+                "from_id": {"type": "string", "description": "Sender ID"},
+                "to_id": {"type": "string", "description": "Receiver ID"},
+                "text": {"type": "string", "description": "Message text"},
+                "member_ids": {
+                    "type": "array",
+                    "items": {"type": "string"},
+                    "description": "List of member IDs for broadcast",
+                },
+            },
+            "required": ["action"],
+        }
+
+    @property
+    def required_permission(self) -> PermissionLevel:
+        return PermissionLevel.READ_ONLY
+
+    @property
+    def input_model(self) -> type[SwarmMessageInput]:
+        return SwarmMessageInput
+
+    def execute(self, args: dict) -> ToolResult:
+        action = args["action"]
+        mailbox = self._manager.mailbox
+
+        if action == "send":
+            from_id = args.get("from_id", "main")
+            to_id = args.get("to_id", "")
+            text = args.get("text", "")
+            if not to_id or not text:
+                return ToolResult(output="send requires to_id and text", is_error=True)
+            mailbox.send(from_id, to_id, text)
+            return ToolResult(output=f"Message sent from {from_id} to {to_id}")
+
+        if action == "receive":
+            from_id = args.get("from_id", "")
+            to_id = args.get("to_id", "")
+            if not from_id or not to_id:
+                return ToolResult(output="receive requires from_id and to_id", is_error=True)
+            msgs = mailbox.receive(from_id, to_id)
+            if not msgs:
+                return ToolResult(output="No messages.")
+            lines = [f"[{m.timestamp}] {m.from_id} -> {m.to_id}: {m.text}" for m in msgs]
+            return ToolResult(output="\n".join(lines))
+
+        if action == "broadcast":
+            from_id = args.get("from_id", "main")
+            member_ids = args.get("member_ids", [])
+            text = args.get("text", "")
+            if not member_ids or not text:
+                return ToolResult(output="broadcast requires member_ids and text", is_error=True)
+            mailbox.broadcast(from_id, member_ids, text)
+            return ToolResult(output=f"Broadcast sent to {len(member_ids)} members")
+
+        if action == "pending":
+            to_id = args.get("to_id", "")
+            if not to_id:
+                return ToolResult(output="pending requires to_id", is_error=True)
+            msgs = mailbox.pending_for(to_id)
+            if not msgs:
+                return ToolResult(output=f"No pending messages for {to_id}")
+            lines = [f"[{m.timestamp}] {m.from_id}: {m.text}" for m in msgs]
+            return ToolResult(output="\n".join(lines))
+
+        return ToolResult(output=f"Unknown action: {action}", is_error=True)