@trac3er/oh-my-god 1.0.2

package/tools/search_providers/brave.py

@@ -0,0 +1,115 @@
+#!/usr/bin/env python3
+"""
+Brave Search Provider for OMG
+
+Uses the Brave Search API (https://api.search.brave.com/res/v1/web/search).
+"""
+
+import json
+import os
+import sys
+import urllib.error
+import urllib.parse
+import urllib.request
+from typing import Any, Dict, List, Optional
+
+_tools_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+if _tools_dir not in sys.path:
+    sys.path.insert(0, _tools_dir)
+
+from web_search import Provider, SearchResult, get_api_key
+
+
+class BraveProvider(Provider):
+    """Search provider using the Brave Search API.
+
+    Endpoint: https://api.search.brave.com/res/v1/web/search
+    Requires an API key (BRAVE_API_KEY env var or credential store).
+    """
+
+    CONFIG_SCHEMA: Dict[str, Any] = {
+        "api_key": {"type": "str", "required": True},
+        "count": {"type": "int", "required": False, "default": 10},
+        "country": {"type": "str", "required": False, "default": ""},
+    }
+
+    API_URL = "https://api.search.brave.com/res/v1/web/search"
+
+    def __init__(self, api_key: Optional[str] = None) -> None:
+        """Initialize BraveProvider.
+
+        Args:
+            api_key: Brave API key. If None, resolves via get_api_key('brave').
+        """
+        self._api_key = api_key or get_api_key("brave")
+
+    def search(self, query: str, **kwargs: Any) -> List[Dict[str, str]]:
+        """Search using the Brave Search API.
+
+        Args:
+            query: The search query string.
+            **kwargs: Optional 'count' (default 10), 'country'.
+
+        Returns:
+            A list of result dicts, or empty list on error.
+        """
+        if not self._api_key:
+            return []
+
+        count = kwargs.get("count", 10)
+        params = {"q": query, "count": str(count)}
+        country = kwargs.get("country", "")
+        if country:
+            params["country"] = country
+
+        url = f"{self.API_URL}?{urllib.parse.urlencode(params)}"
+        req = urllib.request.Request(
+            url,
+            headers={
+                "Accept": "application/json",
+                "Accept-Encoding": "gzip",
+                "X-Subscription-Token": self._api_key,
+                "User-Agent": "OMG-WebSearch/1.0",
+            },
+        )
+
+        try:
+            with urllib.request.urlopen(req, timeout=15) as resp:
+                data = json.loads(resp.read().decode("utf-8"))
+        except (urllib.error.HTTPError, urllib.error.URLError):
+            return []
+        except Exception:
+            return []
+
+        results = []
+        web_results = data.get("web", {}).get("results", [])
+        for item in web_results:
+            results.append({
+                "title": item.get("title", ""),
+                "url": item.get("url", ""),
+                "snippet": item.get("description", ""),
+                "source": "brave",
+            })
+        return results
+
+    def fetch(self, url: str) -> str:
+        """Fetch URL content using stdlib urllib.
+
+        Args:
+            url: The URL to fetch.
+
+        Returns:
+            Page content as string, or empty string on error.
+        """
+        try:
+            req = urllib.request.Request(
+                url,
+                headers={"User-Agent": "OMG-WebSearch/1.0"},
+            )
+            with urllib.request.urlopen(req, timeout=15) as resp:
+                encoding = resp.headers.get_content_charset() or "utf-8"
+                return resp.read().decode(encoding, errors="replace")
+        except (urllib.error.HTTPError, urllib.error.URLError):
+            return ""
+        except Exception:
+            return ""

package/tools/search_providers/exa.py

@@ -0,0 +1,116 @@
+#!/usr/bin/env python3
+"""
+Exa Search Provider for OMG
+
+Uses the Exa AI search API (https://api.exa.ai/search) for semantic web search.
+"""
+
+import json
+import os
+import sys
+import urllib.error
+import urllib.request
+from typing import Any, Dict, List, Optional
+
+_tools_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+if _tools_dir not in sys.path:
+    sys.path.insert(0, _tools_dir)
+
+from web_search import Provider, SearchResult, get_api_key
+
+
+class ExaProvider(Provider):
+    """Search provider using the Exa AI search API.
+
+    Endpoint: https://api.exa.ai/search
+    Requires an API key (EXA_API_KEY env var or credential store).
+    """
+
+    CONFIG_SCHEMA: Dict[str, Any] = {
+        "api_key": {"type": "str", "required": True},
+        "num_results": {"type": "int", "required": False, "default": 10},
+        "use_autoprompt": {"type": "bool", "required": False, "default": True},
+    }
+
+    API_URL = "https://api.exa.ai/search"
+
+    def __init__(self, api_key: Optional[str] = None) -> None:
+        """Initialize ExaProvider.
+
+        Args:
+            api_key: Exa API key. If None, resolves via get_api_key('exa').
+        """
+        self._api_key = api_key or get_api_key("exa")
+
+    def search(self, query: str, **kwargs: Any) -> List[Dict[str, str]]:
+        """Search using the Exa AI API.
+
+        Args:
+            query: The search query string.
+            **kwargs: Optional 'num_results' (default 10), 'use_autoprompt'.
+
+        Returns:
+            A list of result dicts, or empty list on error.
+        """
+        if not self._api_key:
+            return []
+
+        num_results = kwargs.get("num_results", 10)
+        use_autoprompt = kwargs.get("use_autoprompt", True)
+
+        payload = json.dumps({
+            "query": query,
+            "numResults": num_results,
+            "useAutoprompt": use_autoprompt,
+        }).encode("utf-8")
+
+        req = urllib.request.Request(
+            self.API_URL,
+            data=payload,
+            headers={
+                "Content-Type": "application/json",
+                "x-api-key": self._api_key,
+                "User-Agent": "OMG-WebSearch/1.0",
+            },
+            method="POST",
+        )
+
+        try:
+            with urllib.request.urlopen(req, timeout=15) as resp:
+                data = json.loads(resp.read().decode("utf-8"))
+        except (urllib.error.HTTPError, urllib.error.URLError):
+            return []
+        except Exception:
+            return []
+
+        results = []
+        for item in data.get("results", []):
+            results.append({
+                "title": item.get("title", ""),
+                "url": item.get("url", ""),
+                "snippet": item.get("text", item.get("snippet", "")),
+                "source": "exa",
+            })
+        return results
+
+    def fetch(self, url: str) -> str:
+        """Fetch URL content using stdlib urllib.
+
+        Args:
+            url: The URL to fetch.
+
+        Returns:
+            Page content as string, or empty string on error.
+        """
+        try:
+            req = urllib.request.Request(
+                url,
+                headers={"User-Agent": "OMG-WebSearch/1.0"},
+            )
+            with urllib.request.urlopen(req, timeout=15) as resp:
+                encoding = resp.headers.get_content_charset() or "utf-8"
+                return resp.read().decode(encoding, errors="replace")
+        except (urllib.error.HTTPError, urllib.error.URLError):
+            return ""
+        except Exception:
+            return ""

package/tools/search_providers/jina.py

@@ -0,0 +1,104 @@
+#!/usr/bin/env python3
+"""
+Jina Reader Provider for OMG
+
+Uses the Jina Reader API (https://r.jina.ai/) for URL-based content extraction.
+Jina Reader converts web pages to clean, readable text — it is primarily a
+fetch/reader tool rather than a traditional search engine.
+"""
+
+import json
+import os
+import sys
+import urllib.error
+import urllib.request
+from typing import Any, Dict, List, Optional
+
+_tools_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+if _tools_dir not in sys.path:
+    sys.path.insert(0, _tools_dir)
+
+from web_search import Provider, SearchResult, get_api_key
+
+
+class JinaProvider(Provider):
+    """Content extraction provider using Jina Reader API.
+
+    Endpoint: https://r.jina.ai/{url}
+    Optionally accepts an API key (JINA_API_KEY) for higher rate limits.
+    Primary use is fetch() — search() builds a reader URL from the query.
+    """
+
+    CONFIG_SCHEMA: Dict[str, Any] = {
+        "api_key": {"type": "str", "required": False},
+        "return_format": {"type": "str", "required": False, "default": "text"},
+    }
+
+    BASE_URL = "https://r.jina.ai/"
+
+    def __init__(self, api_key: Optional[str] = None) -> None:
+        """Initialize JinaProvider.
+
+        Args:
+            api_key: Jina API key. Optional — Jina works without a key
+                     but has lower rate limits.
+        """
+        self._api_key = api_key or get_api_key("jina")
+
+    def search(self, query: str, **kwargs: Any) -> List[Dict[str, str]]:
+        """Search by treating the query as a URL to read via Jina.
+
+        If the query looks like a URL, fetches it through Jina Reader.
+        Otherwise, returns an empty list (Jina Reader is URL-based, not
+        a search engine).
+
+        Args:
+            query: A URL string to read, or a search query (returns empty).
+            **kwargs: Optional 'return_format' ('text' or 'markdown').
+
+        Returns:
+            A list with one result dict if query is a URL, else empty list.
+        """
+        # Jina Reader is URL-based — only process URLs
+        if not query.startswith(("http://", "https://")):
+            return []
+
+        content = self.fetch(query)
+        if not content:
+            return []
+
+        return [{
+            "title": f"Jina Reader: {query[:80]}",
+            "url": query,
+            "snippet": content[:500],
+            "source": "jina",
+        }]
+
+    def fetch(self, url: str) -> str:
+        """Fetch and extract clean text from a URL using Jina Reader.
+
+        Args:
+            url: The URL to fetch and extract content from.
+
+        Returns:
+            Clean text content, or empty string on error.
+        """
+        reader_url = f"{self.BASE_URL}{url}"
+
+        headers = {
+            "Accept": "text/plain",
+            "User-Agent": "OMG-WebSearch/1.0",
+        }
+        if self._api_key:
+            headers["Authorization"] = f"Bearer {self._api_key}"
+
+        req = urllib.request.Request(reader_url, headers=headers)
+
+        try:
+            with urllib.request.urlopen(req, timeout=20) as resp:
+                encoding = resp.headers.get_content_charset() or "utf-8"
+                return resp.read().decode(encoding, errors="replace")
+        except (urllib.error.HTTPError, urllib.error.URLError):
+            return ""
+        except Exception:
+            return ""

package/tools/search_providers/perplexity.py

@@ -0,0 +1,139 @@
+#!/usr/bin/env python3
+"""
+Perplexity Search Provider for OMG
+
+Uses the Perplexity AI chat completions API
+(https://api.perplexity.ai/chat/completions) for AI-powered web search.
+"""
+
+import json
+import os
+import sys
+import urllib.error
+import urllib.request
+from typing import Any, Dict, List, Optional
+
+_tools_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+if _tools_dir not in sys.path:
+    sys.path.insert(0, _tools_dir)
+
+from web_search import Provider, SearchResult, get_api_key
+
+
+class PerplexityProvider(Provider):
+    """Search provider using the Perplexity AI API.
+
+    Endpoint: https://api.perplexity.ai/chat/completions
+    Requires an API key (PERPLEXITY_API_KEY env var or credential store).
+    Uses the sonar model for online search-augmented responses.
+    """
+
+    CONFIG_SCHEMA: Dict[str, Any] = {
+        "api_key": {"type": "str", "required": True},
+        "model": {"type": "str", "required": False, "default": "sonar"},
+    }
+
+    API_URL = "https://api.perplexity.ai/chat/completions"
+
+    def __init__(self, api_key: Optional[str] = None) -> None:
+        """Initialize PerplexityProvider.
+
+        Args:
+            api_key: Perplexity API key. If None, resolves via
+                     get_api_key('perplexity').
+        """
+        self._api_key = api_key or get_api_key("perplexity")
+
+    def search(self, query: str, **kwargs: Any) -> List[Dict[str, str]]:
+        """Search using the Perplexity AI API.
+
+        Sends the query as a chat message and parses citations from the
+        response into search result format.
+
+        Args:
+            query: The search query string.
+            **kwargs: Optional 'model' (default 'sonar').
+
+        Returns:
+            A list of result dicts, or empty list on error.
+        """
+        if not self._api_key:
+            return []
+
+        model = kwargs.get("model", "sonar")
+
+        payload = json.dumps({
+            "model": model,
+            "messages": [
+                {"role": "user", "content": query},
+            ],
+        }).encode("utf-8")
+
+        req = urllib.request.Request(
+            self.API_URL,
+            data=payload,
+            headers={
+                "Content-Type": "application/json",
+                "Authorization": f"Bearer {self._api_key}",
+                "User-Agent": "OMG-WebSearch/1.0",
+            },
+            method="POST",
+        )
+
+        try:
+            with urllib.request.urlopen(req, timeout=30) as resp:
+                data = json.loads(resp.read().decode("utf-8"))
+        except (urllib.error.HTTPError, urllib.error.URLError):
+            return []
+        except Exception:
+            return []
+
+        results = []
+        # Extract answer text
+        answer = ""
+        choices = data.get("choices", [])
+        if choices:
+            answer = choices[0].get("message", {}).get("content", "")
+
+        # Extract citations if available
+        citations = data.get("citations", [])
+        if citations:
+            for i, url in enumerate(citations):
+                results.append({
+                    "title": f"Citation {i + 1}",
+                    "url": url if isinstance(url, str) else str(url),
+                    "snippet": answer[:200] if i == 0 else "",
+                    "source": "perplexity",
+                })
+        elif answer:
+            # No citations — return answer as a single result
+            results.append({
+                "title": f"Perplexity answer for: {query[:80]}",
+                "url": "",
+                "snippet": answer[:500],
+                "source": "perplexity",
+            })
+
+        return results
+
+    def fetch(self, url: str) -> str:
+        """Fetch URL content using stdlib urllib.
+
+        Args:
+            url: The URL to fetch.
+
+        Returns:
+            Page content as string, or empty string on error.
+        """
+        try:
+            req = urllib.request.Request(
+                url,
+                headers={"User-Agent": "OMG-WebSearch/1.0"},
+            )
+            with urllib.request.urlopen(req, timeout=15) as resp:
+                encoding = resp.headers.get_content_charset() or "utf-8"
+                return resp.read().decode(encoding, errors="replace")
+        except (urllib.error.HTTPError, urllib.error.URLError):
+            return ""
+        except Exception:
+            return ""

package/tools/search_providers/synthetic.py

@@ -0,0 +1,74 @@
+#!/usr/bin/env python3
+"""
+Synthetic Search Provider for OMG
+
+Returns mock/fake results without making any API calls.
+Useful for testing, dry-run mode, and offline development.
+"""
+
+import os
+import sys
+from typing import Any, Dict, List, Optional
+
+# Ensure tools dir is on path for imports
+_tools_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+if _tools_dir not in sys.path:
+    sys.path.insert(0, _tools_dir)
+
+from web_search import Provider, SearchResult
+
+
+class SyntheticProvider(Provider):
+    """Mock search provider that returns fake results without API calls.
+
+    Designed for testing, dry-run mode, and offline development.
+    Does not require any API key or network access.
+    """
+
+    CONFIG_SCHEMA: Dict[str, Any] = {
+        "api_key": {"type": "str", "required": False},
+        "num_results": {"type": "int", "required": False, "default": 3},
+    }
+
+    def __init__(self, api_key: Optional[str] = None) -> None:
+        """Initialize SyntheticProvider.
+
+        Args:
+            api_key: Ignored — synthetic provider needs no credentials.
+        """
+        self._api_key = api_key  # Accepted but unused
+
+    def search(self, query: str, **kwargs: Any) -> List[Dict[str, str]]:
+        """Return synthetic search results for any query.
+
+        Args:
+            query: The search query string.
+            **kwargs: Optional 'num_results' (default 3).
+
+        Returns:
+            A list of fake result dicts with title, url, snippet keys.
+        """
+        num_results = kwargs.get("num_results", 3)
+        results = []
+        for i in range(1, num_results + 1):
+            results.append({
+                "title": f"Synthetic Result {i} for: {query}",
+                "url": f"https://synthetic.example.com/result/{i}",
+                "snippet": f"This is a synthetic snippet #{i} for query '{query}'.",
+                "source": "synthetic",
+            })
+        return results
+
+    def fetch(self, url: str) -> str:
+        """Return synthetic page content for any URL.
+
+        Args:
+            url: The URL to 'fetch'.
+
+        Returns:
+            A synthetic HTML string mentioning the URL.
+        """
+        return (
+            f"<html><head><title>Synthetic Page</title></head>"
+            f"<body><p>Synthetic content for {url}</p></body></html>"
+        )