bareagent-cli 0.1.0__py3-none-any.whl

bareagent/core/handlers/search_utils.py

@@ -0,0 +1,77 @@
+from __future__ import annotations
+
+import os
+from collections.abc import Iterator
+from pathlib import Path, PurePosixPath
+
+IGNORED_PATH_NAMES = {
+    ".git",
+    ".pytest_cache",
+    ".venv",
+    "__pycache__",
+    "node_modules",
+}
+
+
+def is_ignored_descendant(path: Path, search_root: Path) -> bool:
+    """Skip ignored trees unless the caller explicitly searched inside them."""
+    relative = path.relative_to(search_root)
+    return any(part in IGNORED_PATH_NAMES for part in relative.parts)
+
+
+def iter_search_files(search_root: Path) -> Iterator[Path]:
+    if search_root.is_file():
+        yield search_root
+        return
+
+    resolved_root = search_root.resolve(strict=False)
+    for current_root, dir_names, file_names in os.walk(resolved_root):
+        current_path = Path(current_root)
+        dir_names[:] = sorted(
+            name
+            for name in dir_names
+            if not is_ignored_descendant(current_path / name, resolved_root)
+        )
+        for file_name in sorted(file_names):
+            file_path = current_path / file_name
+            if is_ignored_descendant(file_path, resolved_root):
+                continue
+            yield file_path
+
+
+def matches_glob_pattern(candidate: Path, search_root: Path, pattern: str) -> bool:
+    pattern_norm = pattern.replace("\\", "/")
+    relative = candidate.resolve(strict=False).relative_to(
+        search_root.resolve(strict=False)
+    )
+    relative_posix = relative.as_posix()
+
+    if "/" in pattern_norm or "**" in pattern_norm:
+        return any(
+            PurePosixPath(relative_posix).match(variant)
+            for variant in _expand_recursive_variants(pattern_norm)
+        )
+    return PurePosixPath(candidate.name).match(pattern_norm)
+
+
+def requires_recursive_walk(pattern: str) -> bool:
+    pattern_norm = pattern.replace("\\", "/")
+    return "/" in pattern_norm or "**" in pattern_norm
+
+
+def _expand_recursive_variants(pattern: str) -> set[str]:
+    variants = {pattern}
+    changed = True
+    while changed:
+        changed = False
+        new_variants: set[str] = set()
+        for variant in variants:
+            index = variant.find("**/")
+            while index != -1:
+                new_variants.add(variant[:index] + variant[index + 3 :])
+                index = variant.find("**/", index + 1)
+        extra = new_variants - variants
+        if extra:
+            variants.update(extra)
+            changed = True
+    return variants

bareagent/core/handlers/skill.py

@@ -0,0 +1,87 @@
+"""Handler + schema for the ``skill_create`` tool (experiential skill drafting).
+
+Unlike most tools, ``skill_create`` is NOT registered in the global tool set.
+It is exposed only inside the isolated "reflection" ``agent_loop`` call that
+runs after a sufficiently complex multi-turn task (see ``main.py`` and
+``src/planning/skill_gen.py``). Keeping it out of the global set means:
+- the main loop never offers it, so skills are *triggered*, not spontaneous;
+- sub-agents never receive it (isolation, like ``hook_engine``);
+- ``[skills] auto_generate = false`` fully short-circuits — the tool simply
+  does not exist when the reflection never runs.
+
+The handler is a thin wrapper over :class:`bareagent.planning.skill_store.SkillStore`,
+converting expected storage errors into ``Error:`` strings so the model can
+react instead of crashing the loop (see ``error-handling.md``).
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from bareagent.core.schema import tool_schema
+from bareagent.planning.skill_store import derive_skill_slug
+
+if TYPE_CHECKING:
+    from collections.abc import Set as AbstractSet
+
+    from bareagent.planning.skill_store import SkillStore
+
+SKILL_CREATE_TOOL_SCHEMA = tool_schema(
+    "skill_create",
+    (
+        "Save a reusable skill distilled from the workflow you just completed. "
+        "Writes a draft SKILL.md to the pending area; the user promotes it with "
+        "/skill keep. Call at most once per reflection."
+    ),
+    {
+        "name": {
+            "type": "string",
+            "description": "Short kebab-case skill identifier, e.g. 'add-config-section'.",
+        },
+        "description": {
+            "type": "string",
+            "description": "One line starting with 'Use this when ...'.",
+        },
+        "body": {
+            "type": "string",
+            "description": (
+                "Markdown body: Steps / Pitfalls / Verification sections capturing "
+                "the procedure, dead-ends hit, and how success was checked."
+            ),
+        },
+    },
+    ["name", "description", "body"],
+)
+
+_HANDLED_ERRORS = (ValueError, OSError)
+
+
+def run_skill_create(
+    *,
+    store: SkillStore,
+    name: str | None = None,
+    description: str | None = None,
+    body: str | None = None,
+    reserved_names: AbstractSet[str] | None = None,
+) -> str:
+    if not name or not str(name).strip():
+        return "Error: skill_create requires a non-empty 'name'."
+    # Forbid colliding with a checked-in canon skill: a generated skill of that
+    # name would be shadowed by the canon (loader scans canon first) and never
+    # load. Reject so the model picks a distinct name (self-evolution scope:
+    # only generated skills evolve; canon is read-only).
+    if reserved_names:
+        slug = derive_skill_slug(str(name))
+        if slug in reserved_names:
+            return (
+                f"Error: '{slug}' is a built-in (repo) skill name and cannot be "
+                "overwritten. Choose a different name."
+            )
+    try:
+        return store.create_draft(
+            str(name),
+            str(description or ""),
+            str(body or ""),
+        )
+    except _HANDLED_ERRORS as exc:
+        return f"Error: {exc}"

bareagent/core/handlers/subagent_send.py

@@ -0,0 +1,70 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+
+from bareagent.core.schema import tool_schema
+from bareagent.planning.subagent_registry import ResumableContext, SubagentRegistry
+
+SUBAGENT_SEND_TOOL_SCHEMA = tool_schema(
+    "subagent_send",
+    (
+        "Continue a previously spawned foreground subagent, preserving its full "
+        "context. Pass the agent id returned when the subagent was spawned plus a "
+        "follow-up message; the subagent resumes its conversation and returns a "
+        "new result. Only foreground, non-worktree subagents are resumable -- "
+        "background and worktree-isolated subagents do not register a context."
+    ),
+    {
+        "agent_id": {
+            "type": "string",
+            "description": "Id of the subagent to continue (e.g. sa-xxxxxxxx).",
+        },
+        "message": {
+            "type": "string",
+            "description": "Follow-up message to send to the subagent.",
+        },
+    },
+    ["agent_id", "message"],
+)
+
+
+def _resume_footnote(agent_id: str) -> str:
+    return f"\n\n[subagent id {agent_id}: still resumable -- continue with subagent_send]"
+
+
+def run_subagent_send(
+    agent_id: str,
+    message: str,
+    *,
+    registry: SubagentRegistry,
+    run_loop: Callable[[ResumableContext], str],
+) -> str:
+    """Pure-ish driver for the ``subagent_send`` tool (``run_loop`` injected).
+
+    Validates input, looks up the resumable context, appends the follow-up user
+    message, re-enters the loop via ``run_loop``, refreshes the context's
+    position in the registry (so an active multi-turn conversation is not
+    evicted), and returns the new result with a continuation footnote. Never
+    raises on bad input or a missing id -- returns a structured ``Error:`` string
+    instead.
+    """
+    normalized_id = agent_id.strip() if isinstance(agent_id, str) else ""
+    if not normalized_id:
+        return "Error: agent_id must not be empty."
+    if not isinstance(message, str) or not message.strip():
+        return "Error: message must not be empty."
+
+    context = registry.get(normalized_id)
+    if context is None:
+        return (
+            f"Error: subagent {normalized_id} not found. It may have been evicted "
+            "(only the most recent foreground subagents stay resumable) or the "
+            "session was reset (/new, /resume, /import, /clear)."
+        )
+
+    context.messages.append({"role": "user", "content": message})
+    result = run_loop(context)
+    # Re-register on success to refresh FIFO position; if run_loop raised, we
+    # never get here and the context keeps its prior position.
+    registry.register(context)
+    return result + _resume_footnote(normalized_id)

bareagent/core/handlers/web_fetch.py

@@ -0,0 +1,126 @@
+from __future__ import annotations
+
+import html.parser
+import re
+from urllib.error import URLError
+from urllib.request import Request, urlopen
+
+_DEFAULT_TIMEOUT = 15
+_DEFAULT_MAX_LENGTH = 10000
+_USER_AGENT = "BareAgent/1.0"
+_RE_WHITESPACE = re.compile(r"[ \t]+")
+
+
+class _HTMLToText(html.parser.HTMLParser):
+    """将 HTML 转为可读纯文本。
+
+    - 跳过 <script>、<style>、<nav>、<footer>、<header>、<noscript> 标签内容
+    - 在块级元素（p/div/h1-h6/li/br/tr）处插入换行
+    - 合并连续空白
+    """
+
+    _SKIP_TAGS = frozenset({"script", "style", "nav", "footer", "header", "noscript"})
+    _BLOCK_TAGS = frozenset(
+        {
+            "p",
+            "div",
+            "h1",
+            "h2",
+            "h3",
+            "h4",
+            "h5",
+            "h6",
+            "li",
+            "br",
+            "tr",
+            "blockquote",
+            "pre",
+            "section",
+            "article",
+        }
+    )
+
+    def __init__(self) -> None:
+        super().__init__()
+        self._parts: list[str] = []
+        self._skip_depth = 0
+
+    def handle_starttag(self, tag: str, attrs: list[tuple[str, str | None]]) -> None:
+        if tag in self._SKIP_TAGS:
+            self._skip_depth += 1
+        if tag in self._BLOCK_TAGS and self._skip_depth == 0:
+            self._parts.append("\n")
+
+    def handle_endtag(self, tag: str) -> None:
+        if tag in self._SKIP_TAGS and self._skip_depth > 0:
+            self._skip_depth -= 1
+        if tag in self._BLOCK_TAGS and self._skip_depth == 0:
+            self._parts.append("\n")
+
+    def handle_data(self, data: str) -> None:
+        if self._skip_depth == 0:
+            self._parts.append(data)
+
+    def get_text(self) -> str:
+        raw = "".join(self._parts)
+        result_lines: list[str] = []
+        prev_empty = False
+        for line in raw.splitlines():
+            stripped = _RE_WHITESPACE.sub(" ", line).strip()
+            if not stripped:
+                if not prev_empty:
+                    result_lines.append("")
+                prev_empty = True
+            else:
+                result_lines.append(stripped)
+                prev_empty = False
+        return "\n".join(result_lines).strip()
+
+
+def html_to_text(html_content: str) -> str:
+    """将 HTML 字符串转为可读纯文本。"""
+    parser = _HTMLToText()
+    parser.feed(html_content)
+    return parser.get_text()
+
+
+def _truncate(text: str, max_length: int) -> str:
+    """截断文本到指定长度，在最后一个完整行处截断。"""
+    if len(text) <= max_length:
+        return text
+    truncated = text[:max_length]
+    # 尝试在最后一个换行处截断
+    last_newline = truncated.rfind("\n")
+    if last_newline > max_length * 0.8:
+        truncated = truncated[:last_newline]
+    return truncated + "\n\n[... content truncated]"
+
+
+def run_web_fetch(
+    url: str,
+    max_length: int = _DEFAULT_MAX_LENGTH,
+    timeout: int = _DEFAULT_TIMEOUT,
+) -> str:
+    """Fetch content from a URL, convert HTML to text, and truncate."""
+    if not url.startswith(("http://", "https://")):
+        return f"Error: URL must start with http:// or https:// (got: {url})"
+
+    request = Request(url, headers={"User-Agent": _USER_AGENT})
+    try:
+        with urlopen(request, timeout=timeout) as resp:  # noqa: S310
+            content_type = resp.headers.get("Content-Type", "")
+            charset = resp.headers.get_content_charset() or "utf-8"
+
+            raw_bytes = resp.read(max_length * 4)
+            body = raw_bytes.decode(charset, errors="replace")
+    except (URLError, OSError, TimeoutError) as exc:
+        return f"Error fetching URL: {exc}"
+    except ValueError as exc:
+        return f"Error: invalid URL: {exc}"
+
+    if "html" in content_type.lower():
+        text = html_to_text(body)
+    else:
+        text = body
+
+    return _truncate(text, max_length)

bareagent/core/handlers/web_search.py

@@ -0,0 +1,165 @@
+from __future__ import annotations
+
+import base64
+import binascii
+import html
+import json
+import os
+import re
+from urllib.error import URLError
+from urllib.parse import quote_plus
+from urllib.request import Request, urlopen
+
+from bareagent.core.handlers.web_fetch import _DEFAULT_TIMEOUT, html_to_text
+
+_DEFAULT_MAX_RESULTS = 5
+_MAX_READ_BYTES = 512_000
+
+_BING_SEARCH_URL = "https://www.bing.com/search"
+# Bing serves server-rendered organic results (<li class="b_algo">) only to lightweight /
+# non-JS user agents. A modern desktop UA gets a JS shell whose results are injected
+# client-side, so a plain HTTP fetch finds nothing. A text-browser UA forces the SSR path.
+_BING_UA = "Lynx/2.8.9rel.1 libwww-FM/2.14"
+
+_RE_BING_BLOCK = re.compile(r'<li class="b_algo".*?</li>', re.DOTALL)
+_RE_BING_TITLE = re.compile(r"<h2[^>]*>\s*<a[^>]*>(.*?)</a>", re.DOTALL)
+_RE_BING_HREF = re.compile(r'<h2[^>]*>\s*<a[^>]+href="([^"]+)"', re.DOTALL)
+_RE_BING_SNIPPET = re.compile(r'<div class="b_caption".*?<p[^>]*>(.*?)</p>', re.DOTALL)
+# Bing wraps result links in a /ck/a redirect; the real URL is base64url in `u=a1<...>`.
+_RE_BING_REDIRECT_U = re.compile(r"[?&]u=a1([^&]+)")
+
+
+def _search_brave(
+    query: str,
+    max_results: int,
+    timeout: int,
+    api_key: str,
+) -> list[dict[str, str]]:
+    """通过 Brave Search API 搜索。"""
+    url = (
+        f"https://api.search.brave.com/res/v1/web/search"
+        f"?q={quote_plus(query)}&count={max_results}"
+    )
+    request = Request(
+        url,
+        headers={
+            "Accept": "application/json",
+            "Accept-Encoding": "identity",
+            "X-Subscription-Token": api_key,
+        },
+    )
+    with urlopen(request, timeout=timeout) as resp:  # noqa: S310
+        data = json.loads(resp.read(_MAX_READ_BYTES).decode("utf-8"))
+
+    results: list[dict[str, str]] = []
+    for item in data.get("web", {}).get("results", [])[:max_results]:
+        results.append(
+            {
+                "title": item.get("title", ""),
+                "url": item.get("url", ""),
+                "snippet": item.get("description", ""),
+            }
+        )
+    return results
+
+
+def _decode_bing_url(href: str) -> str:
+    """Resolve a Bing /ck/a redirect href to the real destination URL.
+
+    The destination is base64url-encoded in the `u=a1<encoded>` query parameter.
+    Falls back to the raw (unescaped) href when the marker is absent or undecodable.
+    """
+    unescaped = html.unescape(href)
+    match = _RE_BING_REDIRECT_U.search(unescaped)
+    if not match:
+        return unescaped
+    encoded = match.group(1)
+    padding = "=" * (-len(encoded) % 4)
+    try:
+        return base64.urlsafe_b64decode(encoded + padding).decode("utf-8", errors="replace")
+    except (binascii.Error, ValueError):
+        return unescaped
+
+
+def _parse_bing_html(body: str) -> list[dict[str, str]]:
+    """Extract organic results from a Bing HTML search results page."""
+    results: list[dict[str, str]] = []
+    for block in _RE_BING_BLOCK.findall(body):
+        title_match = _RE_BING_TITLE.search(block)
+        href_match = _RE_BING_HREF.search(block)
+        if not title_match or not href_match:
+            continue
+        title = html_to_text(title_match.group(1)).strip()
+        url = _decode_bing_url(href_match.group(1))
+        snippet_match = _RE_BING_SNIPPET.search(block)
+        snippet = html_to_text(snippet_match.group(1)).strip() if snippet_match else ""
+        results.append({"title": title, "url": url, "snippet": snippet})
+    return results
+
+
+def _search_bing_html(
+    query: str,
+    max_results: int,
+    timeout: int,
+) -> list[dict[str, str]]:
+    """通过抓取 Bing HTML 结果页搜索（零配置、免 key、国内可直连）。"""
+    url = f"{_BING_SEARCH_URL}?q={quote_plus(query)}"
+    request = Request(
+        url,
+        headers={"User-Agent": _BING_UA, "Accept-Language": "en-US,en;q=0.9"},
+    )
+    with urlopen(request, timeout=timeout) as resp:  # noqa: S310
+        body = resp.read(_MAX_READ_BYTES).decode("utf-8", errors="replace")
+
+    results = _parse_bing_html(body)
+    if results:
+        return results[:max_results]
+    # Distinguish a genuinely empty result set from an anti-bot / unsupported-browser page
+    # so the caller can surface an explicit error instead of a misleading "No results".
+    if "there are no results" in body.lower():
+        return []
+    raise RuntimeError(
+        "Bing returned no parseable results (likely an anti-bot or unsupported-browser "
+        "page). Set BRAVE_SEARCH_API_KEY to use a reliable search backend."
+    )
+
+
+def _format_results(results: list[dict[str, str]], query: str) -> str:
+    """将搜索结果格式化为可读文本。"""
+    if not results:
+        return f"No results found for: {query}"
+
+    lines: list[str] = [f"Search results for: {query}", ""]
+    for i, r in enumerate(results, 1):
+        lines.append(f"{i}. {r['title']}")
+        lines.append(f"   URL: {r['url']}")
+        if r.get("snippet"):
+            lines.append(f"   {r['snippet']}")
+        lines.append("")
+    return "\n".join(lines).rstrip()
+
+
+def run_web_search(
+    query: str,
+    max_results: int = _DEFAULT_MAX_RESULTS,
+    timeout: int = _DEFAULT_TIMEOUT,
+) -> str:
+    """Search the web and return formatted results."""
+    if not query.strip():
+        return "Error: search query cannot be empty."
+
+    brave_api_key = os.environ.get("BRAVE_SEARCH_API_KEY", "").strip()
+
+    try:
+        if brave_api_key:
+            results = _search_brave(query, max_results, timeout, brave_api_key)
+        else:
+            results = _search_bing_html(query, max_results, timeout)
+    except (URLError, OSError, TimeoutError) as exc:
+        return f"Error searching: {exc}"
+    except RuntimeError as exc:
+        return f"Error: {exc}"
+    except (json.JSONDecodeError, KeyError) as exc:
+        return f"Error parsing search results: {exc}"
+
+    return _format_results(results, query)