bone-agent 1.3.2 → 1.4.0

package/src/tools/helpers/path_resolver.py

@@ -15,6 +15,57 @@ from .file_helpers import _is_reserved_windows_name
 _path_resolution_times = []
 _path_validation_errors = {}
 
+# Session-scoped filesystem access flag
+# When True, boundary enforcement is skipped — agent can access any path.
+_full_filesystem_access = False
+
+# Boundary error prefixes — used by both resolve_and_validate() and is_boundary_error().
+_BOUNDARY_ERROR_PREFIXES = (
+    "Path is outside allowed directories:",
+    "Path is outside repository:",
+)
+
+
+def has_full_filesystem_access() -> bool:
+    """Check if full filesystem access has been granted this session."""
+    return _full_filesystem_access
+
+
+def set_full_filesystem_access(enabled: bool):
+    """Grant or revoke full filesystem access for this session."""
+    global _full_filesystem_access
+    _full_filesystem_access = enabled
+
+
+def _boundary_error_line(result: str) -> Optional[tuple[str, str]]:
+    """Return the boundary prefix and message line from a tool result."""
+    if not result:
+        return None
+
+    for line in result.splitlines():
+        stripped = line.strip()
+        if stripped.lower().startswith("error:"):
+            stripped = stripped[len("error:"):].strip()
+        for prefix in _BOUNDARY_ERROR_PREFIXES:
+            if stripped.startswith(prefix):
+                return prefix, stripped
+    return None
+
+
+def is_boundary_error(result: str) -> bool:
+    """Check if a tool result is a path boundary violation."""
+    return _boundary_error_line(result) is not None
+
+
+def extract_boundary_path(result: str) -> str:
+    """Extract the offending path from a boundary error message."""
+    boundary_line = _boundary_error_line(result)
+    if not boundary_line:
+        return ""
+
+    prefix, line = boundary_line
+    return line[len(prefix):].strip()
+
 
 class PathResolver:
     """Centralized path resolution and validation.
@@ -107,24 +158,30 @@ class PathResolver:
             # Resolve to absolute path (handles .. and symlinks)
             path = path.resolve()
 
-            # Step 2b: Security boundary — path must be within repo_root or vault_path
-            if enforce_boundary:
+            # Step 2b: Security boundary — path must be within repo_root, vault_path,
+            # or the agent's own data directory (~/.bone/).
+            if enforce_boundary and not _full_filesystem_access:
                 try:
                     path.relative_to(self.repo_root)
                 except ValueError:
-                    if self.vault_path is not None:
-                        try:
-                            path.relative_to(self.vault_path)
-                        except ValueError:
+                    # Check ~/.bone/ — agent data dir is always accessible
+                    bone_root = Path.home() / ".bone"
+                    try:
+                        path.relative_to(bone_root)
+                    except ValueError:
+                        if self.vault_path is not None:
+                            try:
+                                path.relative_to(self.vault_path)
+                            except ValueError:
+                                elapsed = time.time() - start_time
+                                _track_validation_error("outside_allowed_roots")
+                                _path_resolution_times.append(elapsed)
+                                return None, f"{_BOUNDARY_ERROR_PREFIXES[0]} {path_str}"
+                        else:
                             elapsed = time.time() - start_time
-                            _track_validation_error("outside_allowed_roots")
+                            _track_validation_error("outside_repo")
                             _path_resolution_times.append(elapsed)
-                            return None, f"Path is outside allowed directories: {path_str}"
-                    else:
-                        elapsed = time.time() - start_time
-                        _track_validation_error("outside_repo")
-                        _path_resolution_times.append(elapsed)
-                        return None, f"Path is outside repository: {path_str}"
+                            return None, f"{_BOUNDARY_ERROR_PREFIXES[1]} {path_str}"
 
             # Step 3: Check existence if required
             if must_exist:

package/src/tools/helpers/plugin_manifest.py

@@ -1,4 +1,4 @@
-"""Plugin manifest for on-demand tool discovery.
+"""Capability manifest for on-demand plugin and skill discovery.
 
 Plugin-tier tools are registered here instead of ToolRegistry at import time.
 This keeps plugin schemas out of the LLM context window until explicitly
@@ -6,19 +6,41 @@ activated via the search_plugins core tool.
 """
 
 import logging
-from typing import Dict, List, Optional
+from dataclasses import dataclass
+from typing import Dict, Iterable, List, Optional
+
+from core.skills import (
+    SearchCandidate,
+    iter_skill_summaries,
+    search_candidates,
+)
+from utils.settings import tool_settings
 
 from .base import ToolDefinition
 
 logger = logging.getLogger(__name__)
 
 
+@dataclass
+class CapabilityMatch:
+    kind: str
+    name: str
+    description: str
+    category: str | None = None
+    tags: list[str] | None = None
+    tool_def: ToolDefinition | None = None
+    preview: str | None = None
+    activated: bool = False
+    already_active: bool = False
+
+
 class PluginManifest:
-    """Index of plugin-tier tools available for on-demand activation.
+    """Index of plugin-tier tools and stored skills for discovery surfaces.
 
-    Tools are registered here when modules with @tool(tier="plugin") are
-    imported. The search_plugins core tool queries this index to find and
-    activate matching plugins.
+    Plugin tools are registered here when modules with @tool(tier="plugin")
+    are imported. Stored skills are discovered from disk on demand. The
+    search_plugins core tool queries this manifest to find and activate or
+    load capabilities.
     """
 
     def __init__(self):
@@ -58,70 +80,77 @@ class PluginManifest:
         """
         return list(self._plugins.values())
 
-    def search(self, query: str, category: str = None, max_results: int = 5) -> List[ToolDefinition]:
-        """Search the manifest for plugins matching a query.
-
-        Args:
-            query: Search query (matched against name, description, tags, category)
-            category: Optional category filter
-            max_results: Maximum number of results to return
-
-        Returns:
-            List of matching ToolDefinitions, sorted by relevance score
-        """
-        query_lower = query.lower()
-        query_terms = query_lower.split()
-
-        scored = []
-        for tool_def in self._plugins.values():
-            # Apply category filter if specified
-            if category and tool_def.category != category:
-                continue
-
-            # Calculate relevance score
-            score = 0.0
-
-            # Exact name match (highest priority)
-            if query_lower == tool_def.name.lower():
-                score += 100.0
-
-            # Name contains query
-            if query_lower in tool_def.name.lower():
-                score += 50.0
-
-            # Name contains individual terms
-            for term in query_terms:
-                if term in tool_def.name.lower():
-                    score += 20.0
-
-            # Description match
-            if query_lower in tool_def.description.lower():
-                score += 30.0
-            for term in query_terms:
-                if term in tool_def.description.lower():
-                    score += 10.0
-
-            # Tag match
-            for tag in tool_def.tags:
-                if query_lower in tag.lower():
-                    score += 15.0
-                for term in query_terms:
-                    if term in tag.lower():
-                        score += 5.0
-
-            # Category match
-            if category and tool_def.category == category:
-                score += 10.0
-            elif not category and query_lower in tool_def.category.lower():
-                score += 15.0
-
-            if score > 0:
-                scored.append((score, tool_def))
-
-        # Sort by score descending
-        scored.sort(key=lambda x: x[0], reverse=True)
-
-        return [tool_def for _, tool_def in scored[:max_results]]
+    def _iter_capabilities(self, category: str = None) -> Iterable[CapabilityMatch]:
+        """Yield available plugin and skill capabilities for discovery surfaces."""
+        include_plugins = category in (None, "plugin")
+        include_skills = category in (None, "skill")
+        disabled_tools = set(tool_settings.disabled_tools or [])
+        hidden_skills = set(tool_settings.hidden_skills or [])
+
+        if include_plugins:
+            for tool_def in self._plugins.values():
+                if tool_def.name in disabled_tools:
+                    continue
+                if category not in (None, "plugin") and tool_def.category != category:
+                    continue
+                yield CapabilityMatch(
+                    kind="plugin",
+                    name=tool_def.name,
+                    description=tool_def.description,
+                    category=tool_def.category,
+                    tags=list(tool_def.tags or []),
+                    tool_def=tool_def,
+                )
+
+        if include_skills:
+            for summary in iter_skill_summaries():
+                if summary.name in hidden_skills:
+                    continue
+                yield CapabilityMatch(
+                    kind="skill",
+                    name=summary.name,
+                    description=summary.description or summary.preview,
+                    category="skill",
+                    tags=summary.tags or ["skill"],
+                    preview=summary.preview,
+                )
+
+    def search_capabilities(
+        self,
+        query: str,
+        category: str = None,
+        max_results: int = 5,
+    ) -> List[CapabilityMatch]:
+        """Search plugins and skills through one shared discovery path."""
+        combined_candidates = [
+            SearchCandidate(
+                item=capability,
+                text=" ".join(
+                    part
+                    for part in [
+                        capability.name,
+                        capability.description,
+                        capability.category or "",
+                        " ".join(capability.tags or []),
+                    ]
+                    if part
+                ),
+                compact_text="",
+                exact_text=capability.name,
+            )
+            for capability in self._iter_capabilities(category=category)
+        ]
+        combined_matches = search_candidates(
+            query,
+            combined_candidates,
+            max_results=max_results,
+            item_key=lambda capability: f"{capability.kind}:{capability.name}",
+        )
+        return [match.item for match in combined_matches]
+
+    def list_all_capabilities(self, category: str = None) -> List[CapabilityMatch]:
+        """Return all available capabilities without fuzzy scoring."""
+        return list(self._iter_capabilities(category=category))
 
     def get_categories(self) -> List[str]:
         """Get all unique categories in the manifest.

package/src/tools/review_sub_agent.py

@@ -172,7 +172,8 @@ def review_changes(
             panel.set_complete({
                 'prompt_tokens': usage.get('prompt_tokens', 0),
                 'completion_tokens': usage.get('completion_tokens', 0),
-                'total_tokens': usage.get('total_tokens', 0)
+                'total_tokens': usage.get('total_tokens', 0),
+                'context_tokens': usage.get('context_tokens', 0),
             })
 
         raw_result = sub_agent_data.get('result', '')

package/src/tools/rg_search.py

@@ -2,25 +2,88 @@
 
 import logging
 import re
-import shlex
+import stat
 import subprocess
 from pathlib import Path
-from typing import Optional
+from typing import Optional, Sequence
 
 from .helpers.base import tool
 from .helpers.formatters import format_tool_result
-from .shell import _prepare_execution_environment, run_shell_command
+from .shell import _execute_direct_command, _prepare_execution_environment
 from .helpers.converters import coerce_bool, coerce_int
+from utils.settings import tool_settings
 
 logger = logging.getLogger(__name__)
 
 # Default match limit for vault searches (separate from repo limit)
 _VAULT_MAX_MATCHES = 20
 
+# Regex for detecting file-path lines in rg output (shared by _annotate_file_sizes and _search_vault)
+_path_line_re = re.compile(r"^[^\s:|].*[/.]")
+
+
+def _format_file_size(size_bytes: int) -> str:
+    """Format file size in human-readable form."""
+    if size_bytes < 1024:
+        return f"{size_bytes} B"
+    elif size_bytes < 1024 * 1024:
+        return f"{size_bytes / 1024:.1f} KB"
+    else:
+        return f"{size_bytes / (1024 * 1024):.1f} MB"
+
+
+def _annotate_file_sizes(formatted_output: str, base_path: Path, output_mode: str = "files_with_matches") -> str:
+    """Append human-readable file sizes to each file path line in rg output.
+
+    Works on files_with_matches and count output modes where each content
+    line starts with a file path. Skips metadata, truncation, and section
+    header lines. Skipped entirely for content mode (no benefit there).
+    """
+    if output_mode == "content":
+        return formatted_output
+
+    lines = formatted_output.split("\n")
+    annotated = []
+    for line in lines:
+        stripped = line.strip()
+        if (not stripped
+                or stripped.startswith("exit_code=")
+                or stripped.startswith("matches=")
+                or stripped.startswith("files=")
+                or stripped.startswith("... (")
+                or stripped.startswith("[repo]")
+                or stripped.startswith("[vault]")):
+            annotated.append(line)
+            continue
+        # Only annotate pure file-path lines (files_with_matches: "file",
+        # count: "file:N"). Skip content-mode match lines ("file:line:match")
+        # which always have 2+ colons or a colon-digit-dash pattern.
+        parts = line.split(":")
+        is_file_line = (
+            _path_line_re.match(line)
+            and len(parts) <= 2
+            and (len(parts) == 1 or parts[1].strip().isdigit())
+        )
+        if is_file_line:
+            file_part = parts[0].strip()
+            full_path = base_path / file_part
+            try:
+                st = full_path.stat()
+                if stat.S_ISREG(st.st_mode):
+                    size = _format_file_size(st.st_size)
+                    annotated.append(f"{line}  {size:>8}")
+                else:
+                    annotated.append(line)
+            except (OSError, ValueError):
+                annotated.append(line)
+        else:
+            annotated.append(line)
+    return "\n".join(annotated)
+
 
 @tool(
     name="rg",
-    description="Search files using ripgrep. Use for ALL code searches (never shell commands). Supports regex, glob/type filtering, and output modes: content, files_with_matches, or count.",
+    description="Search files using ripgrep. Use for ALL code searches (never shell commands). Supports regex, glob/type filtering, and output modes: content, files_with_matches, or count. Use 'path' for one file/directory or 'paths' for multiple files/directories; do not pass space-separated paths in 'path'.",
     parameters={
         "type": "object",
         "properties": {
@@ -30,7 +93,12 @@ _VAULT_MAX_MATCHES = 20
             },
             "path": {
                 "type": "string",
-                "description": "File or directory to search (default: current directory)"
+                "description": "Single file or directory to search (default: current directory). Do not pass multiple space-separated paths here; use 'paths' instead."
+            },
+            "paths": {
+                "type": "array",
+                "items": {"type": "string"},
+                "description": "Multiple files or directories to search. Use this instead of space-separated values in 'path'. If set, 'paths' overrides 'path'."
             },
             "glob": {
                 "type": "string",
@@ -75,6 +143,7 @@ def rg(
     debug_mode: bool = False,
     gitignore_spec = None,
     path: Optional[str] = None,
+    paths: Optional[Sequence[str]] = None,
     glob: Optional[str] = None,
     output_mode: str = "files_with_matches",
     vault_root: Optional[str] = None,
@@ -90,7 +159,8 @@ def rg(
         chat_manager: ChatManager instance (injected by context)
         debug_mode: Whether debug mode is enabled (injected by context)
         gitignore_spec: PathSpec for .gitignore filtering (injected by context)
-        path: File or directory to search in (default: current directory)
+        path: Single file or directory to search in (default: current directory)
+        paths: Multiple files or directories to search; overrides path when set
         glob: Glob pattern to filter files
         output_mode: Output mode (content/files_with_matches/count)
         vault_root: Obsidian vault root path (injected by context)
@@ -103,72 +173,84 @@ def rg(
     if not isinstance(pattern, str) or not pattern.strip():
         return "exit_code=1\nrg requires a non-empty 'pattern' argument."
 
-    # Build rg command from arguments
-    cmd_parts = ["rg"]
+    # Build rg args as a list (bypass string roundtrip to avoid shlex issues with regex metacharacters)
+    args = []
 
     # Add --line-number for content mode
     if output_mode == "content":
-        cmd_parts.append("--line-number")
+        args.append("--line-number")
 
     # Add multiline flag
     multiline = coerce_bool(kwargs.get("multiline"), default=False)
     if multiline:
-        cmd_parts.append("-U")
-        cmd_parts.append("--multiline-dotall")
+        args.append("-U")
+        args.append("--multiline-dotall")
 
     # Add case insensitive flag
     case_insensitive = coerce_bool(kwargs.get("case_insensitive"), default=False)
     if case_insensitive:
-        cmd_parts.append("--ignore-case")
+        args.append("--ignore-case")
 
     # Add context lines flag
     context_lines = coerce_int(kwargs.get("context_lines"))[0] if kwargs.get("context_lines") else None
     if context_lines:
-        cmd_parts.append(f"--context={context_lines}")
+        args.append(f"--context={context_lines}")
 
     # Add glob pattern
     if glob:
-        cmd_parts.append(f"--glob={glob}")
+        args.append(f"--glob={glob}")
 
     # Add file type filter
     file_type = kwargs.get("type")
     if file_type:
-        cmd_parts.append(f"--type={file_type}")
+        args.append(f"--type={file_type}")
 
-    # Add files-with-matches flag for count mode
+    # Add output mode flags
     if output_mode == "files_with_matches":
-        cmd_parts.append("--files-with-matches")
+        args.append("--files-with-matches")
     elif output_mode == "count":
-        cmd_parts.append("--count")
-
-    # Add pattern - quote if it contains spaces
-    if " " in pattern:
-        cmd_parts.append(shlex.quote(pattern))
+        args.append("--count")
+
+    # Pattern and search paths — no quoting needed, subprocess list form bypasses shell
+    args.append(pattern)
+
+    if paths is not None:
+        if not isinstance(paths, Sequence) or isinstance(paths, (str, bytes)):
+            return "exit_code=1\nrg 'paths' must be an array of path strings. Use 'path' for one path."
+        if not paths:
+            return "exit_code=1\nrg 'paths' must be a non-empty array. Omit 'paths' to search the current directory."
+        search_paths = [p for p in paths if isinstance(p, str) and p.strip()]
+        if len(search_paths) != len(paths):
+            return "exit_code=1\nrg 'paths' must contain only non-empty strings."
     else:
-        cmd_parts.append(pattern)
+        search_paths = [path or "."]
 
-    # Add path (default to current directory)
-    search_path = path or "."
-    cmd_parts.append(search_path)
-
-    # Build command string
-    command = " ".join(cmd_parts)
+    args.extend(search_paths)
 
     # Get max_matches from kwargs (default: 100, set to 0 for no limit)
     raw = coerce_int(kwargs.get("max_matches"))[0] if kwargs.get("max_matches") is not None else None
     max_matches = raw if raw is not None and raw >= 0 else 100
 
-    # Execute repo search
+    # Execute repo search directly (no string→shlex roundtrip)
     try:
-        repo_result = run_shell_command(
-            command, repo_root, rg_exe_path, console, debug_mode, gitignore_spec,
-            max_matches=max_matches
+        env = _prepare_execution_environment(repo_root, rg_exe_path)
+
+        result = _execute_direct_command(
+            [str(rg_exe_path)] + args,
+            repo_root, env, debug_mode, console,
+        )
+
+        command_display = "rg " + " ".join(args)
+        repo_result = format_tool_result(
+            result, command=command_display, is_rg=True,
+            debug_mode=debug_mode, max_matches=max_matches,
         )
     except Exception as e:
         return f"exit_code=1\nrg command failed: {str(e)}"
 
     # If no vault configured, return repo results directly
     if not vault_root:
+        repo_result = _annotate_file_sizes(repo_result, repo_root, output_mode)
         return repo_result
 
     # Run vault search and merge results
@@ -184,9 +266,12 @@ def rg(
     )
 
     if not vault_output:
+        repo_result = _annotate_file_sizes(repo_result, repo_root, output_mode)
         return repo_result
 
     # Merge results: repo section + vault section with absolute paths
+    repo_result = _annotate_file_sizes(repo_result, repo_root, output_mode)
+    vault_output = _annotate_file_sizes(vault_output, Path(vault_root), output_mode)
     return _merge_results(repo_result, vault_output, output_mode)
 
 
@@ -257,7 +342,7 @@ def _search_vault(vault_root, rg_exe_path, output_mode, debug_mode, console,
             text=True,
             encoding="utf-8",
             errors="replace",
-            timeout=30,
+            timeout=tool_settings.command_timeout_sec,
             cwd=str(vault_path),
             env=env,
         )
@@ -288,7 +373,6 @@ def _search_vault(vault_root, rg_exe_path, output_mode, debug_mode, console,
         # rg output: "relative/path:linenum:match" or "relative/path-linenum-context"
         # or "relative/path:count" (count mode).  Must contain / or . before any
         # colon to avoid matching content-only lines or binary headers.
-        _path_line_re = re.compile(r"^[^\s:|].*[/.]")
         vault_prefix = str(vault_path)
 
         lines = formatted.split("\n")