vox-code 2.0.0__py3-none-any.whl

voxcli/util/ansi.py

@@ -0,0 +1,82 @@
+"""终端 ANSI 样式辅助 - 支持 Claude Code 风格动画显示"""
+
+import os
+import sys
+
+
+def _color_enabled() -> bool:
+    prop = os.environ.get("VOX_CODE_RENDER_COLOR", "")
+    if prop:
+        return prop.lower() in ("true", "1", "yes")
+    if os.environ.get("NO_COLOR"):
+        return False
+    term = os.environ.get("TERM", "")
+    return term.lower() != "dumb" and sys.stdout.isatty()
+
+
+_ENABLED = _color_enabled()
+
+
+def _wrap(prefix: str, text: str) -> str:
+    if not _ENABLED or not text:
+        return text or ""
+    return f"{prefix}{text}\033[0m"
+
+
+def heading(text: str) -> str:
+    """亮青色粗体 - 用于主标题"""
+    return _wrap("\033[1m\033[36m", text)
+
+
+def section(text: str) -> str:
+    """绿色粗体 - 用于段落标题"""
+    return _wrap("\033[1m\033[32m", text)
+
+
+def subtle(text: str) -> str:
+    """灰色细体 - 用于辅助信息"""
+    return _wrap("\033[2m\033[90m", text)
+
+
+def dim(text: str) -> str:
+    """暗色细体 - 用于状态指示"""
+    return _wrap("\033[2m", text)
+
+
+def code_label(text: str) -> str:
+    """黄色粗体 - 用于代码标签"""
+    return _wrap("\033[1m\033[33m", text)
+
+
+def quote_prefix(text: str) -> str:
+    """暗青色 - 用于引用"""
+    return _wrap("\033[2m\033[36m", text)
+
+
+def emphasis(text: str) -> str:
+    """白色粗体 - 用于强调"""
+    return _wrap("\033[1m", text)
+
+
+def success(text: str) -> str:
+    """绿色 - 用于成功/完成状态"""
+    return _wrap("\033[32m", text)
+
+
+def error(text: str) -> str:
+    """红色 - 用于错误状态"""
+    return _wrap("\033[31m", text)
+
+
+def warning(text: str) -> str:
+    """黄色 - 用于警告"""
+    return _wrap("\033[33m", text)
+
+
+def info(text: str) -> str:
+    """蓝色 - 用于信息"""
+    return _wrap("\033[34m", text)
+
+
+def is_enabled() -> bool:
+    return _ENABLED

voxcli/util/markdown.py

@@ -0,0 +1,98 @@
+"""终端 Markdown 渲染器 - 将 Markdown 文本流式渲染到终端"""
+
+import re
+import sys
+from typing import Optional, TextIO
+
+from .ansi import heading, section, subtle, quote_prefix, emphasis, code_label
+
+
+class TerminalMarkdownRenderer:
+    def __init__(self, stream: Optional[TextIO] = None):
+        self._stream = stream or sys.stdout
+        self._buffer = ""
+        self._in_code_block = False
+        self._in_blockquote = False
+        self._list_level = 0
+
+    def append(self, text: str):
+        self._buffer += text
+        self._flush()
+
+    def finish(self):
+        if self._buffer.strip():
+            self._render(self._buffer)
+            self._buffer = ""
+
+    def _flush(self):
+        while "\n" in self._buffer:
+            idx = self._buffer.index("\n")
+            line = self._buffer[:idx]
+            self._buffer = self._buffer[idx + 1:]
+            self._render(line)
+        if len(self._buffer) > 200:
+            self._render(self._buffer)
+            self._buffer = ""
+
+    def _render(self, line: str):
+        stripped = line.strip()
+
+        if stripped.startswith("```"):
+            self._in_code_block = not self._in_code_block
+            if self._in_code_block:
+                self._write(code_label(stripped[3:] or "code"))
+            return
+
+        if self._in_code_block:
+            self._write(f"  {line}")
+            return
+
+        if stripped.startswith("> "):
+            self._write(quote_prefix(stripped))
+            return
+
+        if stripped.startswith("# "):
+            self._write(heading(stripped[2:]))
+            return
+
+        if stripped.startswith("## "):
+            self._write(section(stripped[3:]))
+            return
+
+        if stripped.startswith("### "):
+            self._write(f"\033[1;36m{stripped[4:]}\033[0m")
+            return
+
+        if stripped.startswith("- ") or stripped.startswith("* "):
+            self._write(f"  • {stripped[2:]}")
+            return
+
+        if re.match(r"^\d+\. ", stripped):
+            self._write(f"  {stripped}")
+            return
+
+        if stripped.startswith("---") or stripped.startswith("***"):
+            self._write(subtle("─" * 40))
+            return
+
+        if stripped == "":
+            self._write("")
+            return
+
+        rendered = self._render_inline(stripped)
+        self._write(rendered)
+
+    @staticmethod
+    def _render_inline(text: str) -> str:
+        text = re.sub(
+            r"\[([^\]]+)\]\(([^)]+)\)",
+            lambda m: f"{emphasis(m.group(1))} ({subtle(m.group(2))})",
+            text,
+        )
+        text = re.sub(r"`([^`]+)`", lambda m: code_label(m.group(1)), text)
+        text = re.sub(r"\*\*([^*]+)\*\*", lambda m: emphasis(m.group(1)), text)
+        text = re.sub(r"\*([^*]+)\*", lambda m: f"\033[3m{m.group(1)}\033[0m", text)
+        return text
+
+    def _write(self, text: str):
+        print(text, file=self._stream)

voxcli/web/__init__.py

@@ -0,0 +1,17 @@
+from .fetch_result import FetchResult
+from .result import SearchResult
+from .network_policy import NetworkPolicy
+from .base import SearchProvider
+from .factory import SearchProviderFactory
+from .zhipu import ZhipuSearchProvider
+from .serpapi import SerpApiSearchProvider
+from .searxng import SearxngSearchProvider
+from .fetcher import WebFetcher
+from .extractor import HtmlExtractor
+
+__all__ = [
+    "FetchResult", "SearchResult", "NetworkPolicy",
+    "SearchProvider", "SearchProviderFactory",
+    "ZhipuSearchProvider", "SerpApiSearchProvider", "SearxngSearchProvider",
+    "WebFetcher", "HtmlExtractor",
+]

voxcli/web/base.py

@@ -0,0 +1,20 @@
+"""搜索提供者接口"""
+
+from typing import List, Protocol
+
+from .result import SearchResult
+
+
+class SearchProvider(Protocol):
+    @property
+    def name(self) -> str:
+        ...
+
+    def search(self, query: str, top_k: int) -> List[SearchResult]:
+        ...
+
+    def is_ready(self) -> bool:
+        ...
+
+    def unavailable_hint(self) -> str:
+        ...

voxcli/web/extractor.py

@@ -0,0 +1,77 @@
+"""HTML 提取器 - 将 HTML 转换为 Markdown"""
+
+import logging
+from typing import Dict, Optional
+from urllib.parse import urljoin
+
+from bs4 import BeautifulSoup, Tag
+
+logger = logging.getLogger(__name__)
+
+
+class HtmlExtractor:
+    def extract(self, html: str, base_url: str) -> Dict[str, str]:
+        soup = BeautifulSoup(html, "lxml")
+        title = self._extract_title(soup)
+        self._remove_noise(soup)
+        markdown = self._to_markdown(soup, base_url)
+        return {"title": title, "markdown": markdown}
+
+    @staticmethod
+    def _extract_title(soup: BeautifulSoup) -> str:
+        title_tag = soup.find("title")
+        return title_tag.get_text(strip=True) if title_tag else ""
+
+    @staticmethod
+    def _remove_noise(soup: BeautifulSoup):
+        for selector in ["script", "style", "nav", "footer", "header",
+                         ".sidebar", ".menu", ".ad", ".advertisement",
+                         ".social-share", ".comments", "[role=complementary]"]:
+            for elem in soup.select(selector):
+                elem.decompose()
+
+    @staticmethod
+    def _to_markdown(soup: BeautifulSoup, base_url: str) -> str:
+        parts = []
+        body = soup.find("body") or soup
+        for elem in body.children:
+            if not isinstance(elem, Tag):
+                continue
+            tag = elem.name.lower() if elem.name else ""
+            if tag in ("h1", "h2", "h3", "h4", "h5", "h6"):
+                level = int(tag[1])
+                parts.append(f"\n{'#' * level} {elem.get_text(strip=True)}\n")
+            elif tag == "p":
+                text = elem.get_text(strip=True)
+                if text:
+                    parts.append(f"\n{text}\n")
+            elif tag in ("ul", "ol"):
+                for li in elem.find_all("li"):
+                    prefix = "- " if tag == "ul" else "1. "
+                    parts.append(f"{prefix}{li.get_text(strip=True)}\n")
+                parts.append("\n")
+            elif tag == "pre":
+                code = elem.get_text()
+                parts.append(f"\n```\n{code}\n```\n")
+            elif tag == "code":
+                parts.append(f"`{elem.get_text(strip=True)}`")
+            elif tag == "a":
+                href = elem.get("href", "")
+                if href and base_url:
+                    href = urljoin(base_url, href)
+                text = elem.get_text(strip=True)
+                if text and href:
+                    parts.append(f"[{text}]({href})")
+            elif tag == "img":
+                src = elem.get("src", "")
+                if src and base_url:
+                    src = urljoin(base_url, src)
+                alt = elem.get("alt", "")
+                parts.append(f"![{alt}]({src})")
+            elif tag == "blockquote":
+                text = elem.get_text(strip=True)
+                if text:
+                    parts.append(f"\n> {text}\n")
+            elif tag in ("table", "div", "section", "article", "main"):
+                parts.append(HtmlExtractor._to_markdown(elem, base_url))
+        return "\n".join(parts).strip()

voxcli/web/factory.py

@@ -0,0 +1,38 @@
+"""搜索提供者工厂 - 根据环境变量创建搜索提供者"""
+
+import os
+import logging
+from typing import Optional
+
+from ..config import pai_config
+from .base import SearchProvider
+from .zhipu import ZhipuSearchProvider
+from .serpapi import SerpApiSearchProvider
+from .searxng import SearxngSearchProvider
+
+logger = logging.getLogger(__name__)
+
+
+class SearchProviderFactory:
+    _instance: Optional[SearchProvider] = None
+
+    @classmethod
+    def create(cls) -> SearchProvider:
+        if cls._instance is not None:
+            return cls._instance
+
+        provider_name = os.environ.get("SEARCH_PROVIDER", "serpapi").lower()
+        config = pai_config.get_provider("glm") or pai_config.get_provider("deepseek") or {}
+
+        if provider_name == "zhipu":
+            api_key = config.get("api_key", "") if config else ""
+            cls._instance = ZhipuSearchProvider(api_key=api_key)
+        elif provider_name == "searxng":
+            base_url = os.environ.get("SEARXNG_BASE_URL", "http://localhost:8888")
+            cls._instance = SearxngSearchProvider(base_url=base_url)
+        else:
+            api_key = os.environ.get("SERPAPI_API_KEY", "")
+            cls._instance = SerpApiSearchProvider(api_key=api_key)
+
+        logger.info("Created search provider: %s", cls._instance.name)
+        return cls._instance

voxcli/web/fetch_result.py

@@ -0,0 +1,27 @@
+"""网页抓取结果"""
+
+from dataclasses import dataclass
+
+
+@dataclass
+class FetchResult:
+    url: str
+    title: str
+    markdown: str
+    content_length: int
+    truncated: bool
+
+    @staticmethod
+    def ok(url: str, title: str, markdown: str,
+            content_length: int, truncated: bool) -> "FetchResult":
+        return FetchResult(url, title, markdown, content_length, truncated)
+
+    @property
+    def body_empty(self) -> bool:
+        return not self.markdown.strip()
+
+    @property
+    def hint(self) -> str:
+        if self.body_empty:
+            return "正文为空，可能是 SPA 或防爬墙（已知边界，不重试）"
+        return ""

voxcli/web/fetcher.py

@@ -0,0 +1,42 @@
+"""网页抓取器 - 使用 httpx 获取网页内容"""
+
+import logging
+from typing import Dict, Optional
+
+import httpx
+
+logger = logging.getLogger(__name__)
+
+_DEFAULT_TIMEOUT = 30
+_MAX_RESPONSE_BYTES = 5 * 1024 * 1024  # 5MB
+
+
+class WebFetcher:
+    def __init__(self, timeout: int = _DEFAULT_TIMEOUT):
+        self._timeout = timeout
+
+    def fetch(self, url: str) -> Dict[str, str]:
+        logger.info("Fetching URL: %s", url)
+        response = httpx.get(
+            url,
+            timeout=self._timeout,
+            follow_redirects=True,
+            headers={
+                "User-Agent": ("Mozilla/5.0 (compatible; VoxCode/1.0; "
+                               "+https://github.com/vox-code)"),
+                "Accept": "text/html,application/xhtml+xml;q=0.9,*/*;q=0.8",
+                "Accept-Language": "zh-CN,zh;q=0.9,en;q=0.8",
+            },
+        )
+        response.raise_for_status()
+
+        body = response.text
+        if len(body) > _MAX_RESPONSE_BYTES:
+            body = body[:_MAX_RESPONSE_BYTES]
+            logger.warning("Response truncated to %d bytes", _MAX_RESPONSE_BYTES)
+
+        return {
+            "url": str(response.url),
+            "body": body,
+            "content_type": response.headers.get("content-type", ""),
+        }

voxcli/web/network_policy.py

@@ -0,0 +1,49 @@
+"""网络策略 - SSRF 防护和速率限制"""
+
+import ipaddress
+import time
+import re
+from dataclasses import dataclass
+from typing import Optional
+from urllib.parse import urlparse
+
+
+@dataclass
+class NetworkPolicy:
+    rate_limit_per_minute: int = 10
+    allowed_schemes: tuple = ("http", "https")
+    block_private_ip: bool = True
+
+    def __init__(self, rate_per_minute: int = 10):
+        self.rate_limit_per_minute = rate_per_minute
+        self._call_timestamps: list = []
+
+    def check_url(self, url: str) -> Optional[str]:
+        if not url:
+            return "URL 为空"
+        parsed = urlparse(url)
+        if parsed.scheme not in ("http", "https"):
+            return f"不支持的协议: {parsed.scheme}"
+        return self._check_ip(parsed.hostname) if self.block_private_ip else None
+
+    def _check_ip(self, hostname: Optional[str]) -> Optional[str]:
+        if not hostname:
+            return "无法解析 hostname"
+        if hostname in ("localhost", "127.0.0.1", "::1"):
+            return f"禁止访问本地地址: {hostname}"
+        try:
+            addr = ipaddress.ip_address(hostname)
+            if addr.is_private or addr.is_loopback or addr.is_link_local:
+                return f"禁止访问内网地址: {hostname}"
+        except ValueError:
+            pass
+        return None
+
+    def acquire(self) -> Optional[str]:
+        now = time.time()
+        window = 60.0
+        self._call_timestamps = [t for t in self._call_timestamps if now - t < window]
+        if len(self._call_timestamps) >= self.rate_limit_per_minute:
+            return f"请求频率超过限制（{self.rate_limit_per_minute}/分钟）"
+        self._call_timestamps.append(now)
+        return None

voxcli/web/result.py

@@ -0,0 +1,23 @@
+"""搜索结果"""
+
+from dataclasses import dataclass
+
+
+@dataclass
+class SearchResult:
+    title: str
+    url: str
+    snippet: str
+    position: int
+    source: str = ""
+
+    def __post_init__(self):
+        self._source = self.source
+
+    @property
+    def source(self) -> str:
+        return self._source
+
+    @source.setter
+    def source(self, value: str):
+        self._source = value

voxcli/web/searxng.py

@@ -0,0 +1,55 @@
+"""SearXNG 搜索提供者（自托管）"""
+
+import json
+import logging
+from typing import List, Optional
+
+import httpx
+
+from .result import SearchResult
+from .base import SearchProvider
+
+logger = logging.getLogger(__name__)
+
+
+class SearxngSearchProvider:
+    def __init__(self, base_url: str = "http://localhost:8888"):
+        self._base_url = base_url.rstrip("/")
+
+    @property
+    def name(self) -> str:
+        return "SearXNG"
+
+    def search(self, query: str, top_k: int = 5) -> List[SearchResult]:
+        response = httpx.get(
+            f"{self._base_url}/search",
+            params={"q": query, "format": "json", "language": "zh-CN", "categories": "general"},
+            timeout=30,
+        )
+        response.raise_for_status()
+        data = response.json()
+        return self._parse_results(data, top_k)
+
+    def is_ready(self) -> bool:
+        try:
+            httpx.get(f"{self._base_url}/health", timeout=5).raise_for_status()
+            return True
+        except Exception:
+            return False
+
+    def unavailable_hint(self) -> str:
+        return f"SearXNG 无法连接（{self._base_url}），请确保服务已启动"
+
+    @staticmethod
+    def _parse_results(data: dict, top_k: int) -> List[SearchResult]:
+        results = []
+        items = data.get("results", [])
+        for i, item in enumerate(items[:top_k]):
+            results.append(SearchResult(
+                title=item.get("title", ""),
+                url=item.get("url", ""),
+                snippet=item.get("content", ""),
+                position=i + 1,
+                source="searxng",
+            ))
+        return results

voxcli/web/serpapi.py

@@ -0,0 +1,53 @@
+"""SerpAPI 搜索提供者"""
+
+import json
+import logging
+from typing import List, Optional
+
+import httpx
+
+from .result import SearchResult
+from .base import SearchProvider
+
+logger = logging.getLogger(__name__)
+
+
+class SerpApiSearchProvider:
+    def __init__(self, api_key: str = ""):
+        self._api_key = api_key
+
+    @property
+    def name(self) -> str:
+        return "SerpAPI"
+
+    def search(self, query: str, top_k: int = 5) -> List[SearchResult]:
+        if not self._api_key:
+            return []
+        response = httpx.get(
+            "https://serpapi.com/search",
+            params={"q": query, "api_key": self._api_key, "engine": "google", "num": min(top_k, 10)},
+            timeout=30,
+        )
+        response.raise_for_status()
+        data = response.json()
+        return self._parse_results(data)
+
+    def is_ready(self) -> bool:
+        return bool(self._api_key)
+
+    def unavailable_hint(self) -> str:
+        return "SerpAPI 搜索需要配置 SERPAPI_API_KEY 环境变量"
+
+    @staticmethod
+    def _parse_results(data: dict) -> List[SearchResult]:
+        results = []
+        organic = data.get("organic_results", [])
+        for i, item in enumerate(organic[:10]):
+            results.append(SearchResult(
+                title=item.get("title", ""),
+                url=item.get("link", ""),
+                snippet=item.get("snippet", ""),
+                position=i + 1,
+                source="serpapi",
+            ))
+        return results

voxcli/web/zhipu.py

@@ -0,0 +1,55 @@
+"""智谱搜索提供者 - 使用智谱 API 进行搜索"""
+
+import json
+import logging
+from typing import List, Optional
+
+import httpx
+
+from .result import SearchResult
+from .base import SearchProvider
+
+logger = logging.getLogger(__name__)
+
+
+class ZhipuSearchProvider:
+    def __init__(self, api_key: str = "", base_url: str = "https://open.bigmodel.cn/api/paas/v4"):
+        self._api_key = api_key
+        self._base_url = base_url
+
+    @property
+    def name(self) -> str:
+        return "zhipu"
+
+    def search(self, query: str, top_k: int = 5) -> List[SearchResult]:
+        if not self._api_key:
+            return []
+        response = httpx.post(
+            f"{self._base_url}/tools/web_search",
+            headers={"Authorization": f"Bearer {self._api_key}", "Content-Type": "application/json"},
+            json={"query": query, "top_k": min(top_k, 10)},
+            timeout=30,
+        )
+        response.raise_for_status()
+        data = response.json()
+        return self._parse_results(data)
+
+    def is_ready(self) -> bool:
+        return bool(self._api_key)
+
+    def unavailable_hint(self) -> str:
+        return "智谱搜索需要配置 GLM_API_KEY 环境变量"
+
+    @staticmethod
+    def _parse_results(data: dict) -> List[SearchResult]:
+        results = []
+        items = data.get("results", []) or data.get("data", [])
+        for i, item in enumerate(items):
+            results.append(SearchResult(
+                title=item.get("title", ""),
+                url=item.get("url", "") or item.get("link", ""),
+                snippet=item.get("snippet", "") or item.get("content", ""),
+                position=i + 1,
+                source="zhipu",
+            ))
+        return results