bone-agent 1.3.3 → 1.4.0

package/src/tools/__init__.py

@@ -5,6 +5,8 @@ capabilities for the bone-agent AI assistant.
 """
 
 import logging
+import sys
+from pathlib import Path
 
 _logger = logging.getLogger(__name__)
 
@@ -56,7 +58,7 @@ from . import sub_agent
 from . import task_list
 from . import select_option
 
-# search_plugins — core meta-tool for plugin discovery
+# search_plugins — core meta-tool for capability discovery and loading
 from . import search_plugins
 
 # Obsidian tools — conditional registration (register() pattern, NOT @tool at import)
@@ -99,8 +101,7 @@ __all__ = [
 ]
 
 # =============================================================================
-# Backward compatibility: Re-export helpers at package level
-# This allows imports like: from tools.base import tool
+# Re-export helpers at package level
 # =============================================================================
 from .helpers import (
     ToolDefinition,
@@ -126,87 +127,25 @@ except Exception as e:
 # Plugin modules with @tool(tier="plugin") register into the manifest
 # and are only activated in ToolRegistry on-demand via search_plugins.
 try:
-    from .helpers.loader import load_plugin_tools
-    load_plugin_tools()
-except Exception as e:
-    _logger.debug("Failed to load plugin tools: %s", e)
+    from .helpers.loader import discover_tools
+    from .helpers.plugin_manifest import plugin_manifest
 
-# Make base module available for backward compatibility
-import sys
-from types import ModuleType
-
-# Create a synthetic 'base' module that re-exports from helpers
-_base_module = ModuleType('tools.base')
-_base_module.__dict__.update({
-    'ToolDefinition': ToolDefinition,
-    'ToolRegistry': ToolRegistry,
-    'tool': tool,
-    'build_context': build_context,
-    'get_tool_schemas': get_tool_schemas,
-    'TOOLS': TOOLS,
-})
-sys.modules['tools.base'] = _base_module
-
-# Create synthetic modules for other helpers
-_formatters_module = ModuleType('tools.formatters')
-_formatters_module.__dict__.update({
-    'format_tool_result': format_tool_result,
-    'format_file_result': format_file_result,
-    '_build_diff': _build_diff,
-    '_detect_newline': _detect_newline,
-})
-sys.modules['tools.formatters'] = _formatters_module
-
-_file_helpers_module = ModuleType('tools.file_helpers')
-from .helpers.file_helpers import (
-    _is_reserved_windows_name,
-    GitignoreFilter,
-)
-_file_helpers_module.__dict__.update({
-    '_is_reserved_windows_name': _is_reserved_windows_name,
-    'GitignoreFilter': GitignoreFilter,
-})
-sys.modules['tools.file_helpers'] = _file_helpers_module
-
-# Path resolver module
-_path_resolver_module = ModuleType('tools.path_resolver')
-from .helpers.path_resolver import PathResolver
-_path_resolver_module.__dict__.update({
-    'PathResolver': PathResolver,
-})
-sys.modules['tools.path_resolver'] = _path_resolver_module
-
-_converters_module = ModuleType('tools.converters')
-from .helpers.converters import coerce_int, coerce_bool
-_converters_module.__dict__.update({
-    'coerce_int': coerce_int,
-    'coerce_bool': coerce_bool,
-})
-sys.modules['tools.converters'] = _converters_module
-
-_loader_module = ModuleType('tools.loader')
-from .helpers.loader import (
-    discover_tools,
-    load_builtin_tools,
-    load_plugin_tools,
-    load_all_tools,
-    list_registered_tools,
-)
-_loader_module.__dict__.update({
-    'discover_tools': discover_tools,
-    'load_builtin_tools': load_builtin_tools,
-    'load_plugin_tools': load_plugin_tools,
-    'load_all_tools': load_all_tools,
-    'list_registered_tools': list_registered_tools,
-})
-sys.modules['tools.loader'] = _loader_module
-
-_parallel_executor_module = ModuleType('tools.parallel_executor')
-from .helpers.parallel_executor import ToolCall, ToolResult, ParallelToolExecutor
-_parallel_executor_module.__dict__.update({
-    'ToolCall': ToolCall,
-    'ToolResult': ToolResult,
-    'ParallelToolExecutor': ParallelToolExecutor,
-})
-sys.modules['tools.parallel_executor'] = _parallel_executor_module
+    repo_root = Path(__file__).resolve().parents[2]
+    src_dir = str(repo_root / "src")
+    if src_dir not in sys.path:
+        sys.path.insert(0, src_dir)
 
+    discover_tools([str(repo_root / "tool_plugins")])
+
+    _logger.info(
+        "Plugin manifest: %s plugins available (categories: %s)",
+        plugin_manifest.plugin_count(),
+        plugin_manifest.get_categories(),
+    )
+
+    # Re-apply disabled_tools now that plugins are in the manifest
+    for tool_name in tool_settings.disabled_tools:
+        if plugin_manifest.has_plugin(tool_name):
+            ToolRegistry.disable(tool_name)
+except Exception as e:
+    _logger.debug("Failed to load plugin tools: %s", e)

package/src/tools/create_file.py

@@ -33,7 +33,7 @@ def _validate_create_path(
         path_str,
         check_gitignore=True,
         must_exist=False,  # File doesn't need to exist yet
-        enforce_boundary=vault_path is not None,
+        enforce_boundary=True,
     )
 
 

package/src/tools/directory.py

@@ -139,7 +139,7 @@ def _validate_directory_path(
         check_gitignore=False,  # Directory listing shows everything
         must_exist=True,
         must_be_dir=True,  # Must be a directory
-        enforce_boundary=vault_path is not None
+        enforce_boundary=True
     )
 
     if error:

package/src/tools/edit.py

@@ -184,7 +184,7 @@ def _resolve_repo_path(path_str, repo_root, gitignore_spec=None, vault_root=None
         check_gitignore=not skip_gitignore,
         must_exist=True,
         must_be_file=False,  # We'll check this separately
-        enforce_boundary=vault_path is not None,
+        enforce_boundary=True,
     )
 
     if error:
@@ -455,6 +455,7 @@ def edit_file(
     gitignore_spec = None,
     context_lines: int = 3,
     vault_root: str = None,
+    reason: str = None,
 ) -> str | Text:
     """Apply search/replace edit to a file.
 
@@ -468,6 +469,7 @@ def edit_file(
         gitignore_spec: PathSpec for .gitignore filtering (injected by context)
         context_lines: Number of context lines in diff
         vault_root: Obsidian vault root path (injected by context)
+        reason: Brief explanation shown during confirmation
 
     Returns:
         Edit result with diff
@@ -484,6 +486,8 @@ def edit_file(
         "replace": replace,
         "context_lines": context_lines,
     }
+    if reason:
+        arguments["reason"] = reason
 
     # Preview edit (confirmation workflow handled by orchestrator)
     try:

package/src/tools/file_reader.py

@@ -34,7 +34,7 @@ def _validate_read_path(
         check_gitignore=True,
         must_exist=True,
         must_be_file=True,
-        enforce_boundary=vault_path is not None,
+        enforce_boundary=True,
     )
 
 

package/src/tools/helpers/__init__.py

@@ -5,7 +5,7 @@ execution, and supporting utilities. It is not intended to be imported
 directly by end users - import from tools/ instead for backward compatibility.
 
 For creating custom tools, use:
-    from tools import tool  # or from tools.base import tool
+    from tools import tool  # or from tools.helpers.base import tool
 """
 
 # Core infrastructure
@@ -48,9 +48,6 @@ from .converters import (
 # Tool loading and discovery
 from .loader import (
     discover_tools,
-    load_builtin_tools,
-    load_plugin_tools,
-    load_all_tools,
     list_registered_tools,
 )
 
@@ -91,9 +88,6 @@ __all__ = [
     'coerce_bool',
     # Tool loading and discovery
     'discover_tools',
-    'load_builtin_tools',
-    'load_plugin_tools',
-    'load_all_tools',
     'list_registered_tools',
     # Plugin manifest
     'PluginManifest',

package/src/tools/helpers/base.py

@@ -92,13 +92,13 @@ class ToolDefinition:
 
 # Named groups of related tools for bulk enable/disable
 TOOL_GROUPS = {
-    "file_ops": {
-        "label": "File Operations",
-        "tools": ["read_file", "create_file", "edit_file", "list_directory"],
-    },
-    "task_mgmt": {
-        "label": "Task Management",
-        "tools": ["create_task_list", "complete_task", "show_task_list"],
+    "core": {
+        "label": "Core",
+        "tools": [
+            "rg", "read_file", "create_file", "edit_file", "list_directory",
+            "execute_command", "web_search", "sub_agent", "search_plugins",
+            "select_option", "create_task_list", "complete_task", "show_task_list",
+        ],
     },
 }
 
@@ -120,30 +120,42 @@ class ToolRegistry:
             cls._instance = super().__new__(cls)
         return cls._instance
 
+    @classmethod
+    def _is_known_name(cls, name: str) -> bool:
+        """Check if a name belongs to a registered tool or known plugin."""
+        if name in cls._tools:
+            return True
+        # Lazy check against plugin manifest for names not yet activated
+        from tools.helpers.plugin_manifest import plugin_manifest
+        return plugin_manifest.has_plugin(name)
+
     @classmethod
     def disable(cls, name: str) -> bool:
-        """Disable a tool by name.
+        """Disable a tool or plugin by name.
+
+        Works for core tools (in _tools) and plugins (known via manifest
+        but not yet activated).
 
         Args:
-            name: Tool name to disable
+            name: Tool or plugin name to disable
 
         Returns:
-            True if tool was found and disabled, False if not registered
+            True if name was recognized and disabled
         """
-        if name in cls._tools:
+        if name in cls._tools or cls._is_known_name(name):
             cls._disabled[name] = None
             return True
         return False
 
     @classmethod
     def enable(cls, name: str) -> bool:
-        """Enable a previously disabled tool.
+        """Enable a previously disabled tool or plugin.
 
         Args:
-            name: Tool name to enable
+            name: Tool or plugin name to enable
 
         Returns:
-            True if tool was re-enabled, False if it wasn't disabled
+            True if it was disabled and is now re-enabled
         """
         if name in cls._disabled:
             del cls._disabled[name]
@@ -305,25 +317,32 @@ class ToolRegistry:
         Returns:
             Number of enabled tools (excludes disabled tools)
         """
-        return len(cls._tools) - len(cls._disabled)
+        return sum(1 for name in cls._tools if name not in cls._disabled)
 
     # =========================================================================
     # Plugin activation and TTL management
     # =========================================================================
 
     @classmethod
-    def activate_plugin(cls, tool_def, ttl=None) -> None:
+    def activate_plugin(cls, tool_def, ttl=None) -> bool:
         """Activate a plugin-tier tool by registering it with a TTL.
 
         Args:
             tool_def: ToolDefinition with tier="plugin"
             ttl: Number of turns before eviction (default: cls._default_plugin_ttl)
+
+        Returns:
+            True if the plugin was activated, False if it is disabled
         """
+        if cls.is_disabled(tool_def.name):
+            _logger.debug("Skipping activation for disabled plugin: %s", tool_def.name)
+            return False
         if ttl is None:
             ttl = cls._default_plugin_ttl
         cls._tools[tool_def.name] = tool_def
         cls._plugin_ttl[tool_def.name] = ttl
         _logger.debug(f"Plugin activated: {tool_def.name} (TTL={ttl})")
+        return True
 
     @classmethod
     def deactivate_plugin(cls, name: str) -> bool:
@@ -405,6 +424,35 @@ def get_terminal_policy(tool_name: str) -> str:
     return TERMINAL_NONE  # Default to none for unknown tools
 
 
+def _enrich_plugin_metadata(tool_def: ToolDefinition) -> None:
+    """Auto-generate description and/or tags for a plugin if missing."""
+    if tool_def.description and tool_def.tags:
+        return
+
+    try:
+        source = inspect.getsource(tool_def.handler) if tool_def.handler else ""
+    except (OSError, TypeError):
+        source = ""
+
+    content = f"{tool_def.name}\n{tool_def.description}\n{source}"
+    try:
+        from core.metadata import generate_metadata
+        generated = generate_metadata(content, tool_def.name)
+    except Exception:
+        _logger.debug("Plugin metadata enrichment failed for '%s'", tool_def.name, exc_info=True)
+        return
+
+    if not tool_def.description:
+        tool_def.description = str(generated.get("description", "")).strip()
+    if not tool_def.tags:
+        raw_tags = generated.get("tags")
+        if isinstance(raw_tags, str):
+            raw_tags = [raw_tags]
+        elif not isinstance(raw_tags, list):
+            raw_tags = []
+        tool_def.tags = [str(tag).strip() for tag in raw_tags if str(tag).strip()]
+
+
 def tool(
     name: str,
     description: str,
@@ -475,6 +523,7 @@ def tool(
 
         # Plugin-tier tools go to the manifest, not the registry
         if tier == "plugin":
+            _enrich_plugin_metadata(tool_def)
             from .plugin_manifest import plugin_manifest
             plugin_manifest.register(tool_def)
         else:

package/src/tools/helpers/loader.py

@@ -51,7 +51,7 @@ def _load_module_from_path(module_name: str, file_path: Path) -> Optional[object
 
         module = importlib.util.module_from_spec(spec)
 
-        # For user tools (not in src/utils/tools/), set package to None
+        # For external tool modules (not in src/tools/), set package to None
         # to force absolute imports instead of relative imports
         from tools import __file__ as tools_init_file
         tools_dir = Path(tools_init_file).parent
@@ -113,7 +113,7 @@ def discover_tools(directories: List[str]) -> int:
             # Create unique module name
             module_name = f"tools_{py_file.stem}_{hash(str(py_file)) & 0xFFFFFFFF}"
 
-            # Skip modules already loaded (e.g. cron re-calling load_all_tools)
+            # Skip modules already loaded (e.g. cron re-calling discover_tools)
             if module_name in sys.modules:
                 logger.debug(f"Module already loaded, skipping: {module_name}")
                 continue
@@ -133,92 +133,6 @@ def discover_tools(directories: List[str]) -> int:
     return new_tools
 
 
-def load_builtin_tools() -> int:
-    """Load built-in tools from src/utils/tools/.
-
-    Returns:
-        Number of tools loaded
-
-    Note:
-        Built-in tools are already imported in __init__.py, which triggers
-        @tool decorator registration. This function returns the count of
-        currently registered built-in tools.
-    """
-    # Built-in tools are already imported in utils/tools/__init__.py
-    # which triggers @tool decorator registration.
-    # Just return the count of tools currently in registry.
-    return ToolRegistry.tool_count()
-
-
-def load_plugin_tools() -> int:
-    """Load plugin tools from tool_plugins/ directory.
-
-    Plugin modules are imported, which triggers @tool(tier="plugin") decorator
-    registration into the PluginManifest (NOT ToolRegistry). This keeps plugin
-    schemas out of the LLM context window until activated via search_plugins.
-
-    Returns:
-        Number of plugin modules loaded
-
-    Note:
-        - tool_plugins/ directory at repository root
-        - Plugin tools registered in PluginManifest, not ToolRegistry
-    """
-    from .plugin_manifest import plugin_manifest
-
-    # Get repository root (assumes we're in src/tools/helpers/)
-    current_dir = Path(__file__).parent
-    repo_root = current_dir.parent.parent.parent
-
-    # Define plugin tool directories
-    plugin_directories = [
-        str(repo_root / "tool_plugins"),
-    ]
-
-    # Discover tools in plugin directories
-    modules_loaded = discover_tools(plugin_directories)
-
-    logger.info(
-        f"Plugin manifest: {plugin_manifest.plugin_count()} plugins available "
-        f"(categories: {plugin_manifest.get_categories()})"
-    )
-
-    return modules_loaded
-
-
-def load_all_tools() -> int:
-    """Load all tools (built-in and plugin tools).
-
-    Returns:
-        Total number of tools loaded
-
-    Discovery order:
-        1. Built-in tools (src/tools/*.py)
-        2. Plugin tools (tool_plugins/*.py)
-
-    Note:
-        Plugin tools loaded later can override built-in tools.
-    """
-    logger.info("Starting tool loading...")
-
-    # Load built-in tools first
-    builtin_count = load_builtin_tools()
-
-    # Then load plugin tools (can override built-ins)
-    plugin_count = load_plugin_tools()
-
-    total_count = builtin_count + plugin_count
-    total_registered = ToolRegistry.tool_count()
-
-    logger.info(
-        f"Tool loading complete: {builtin_count} built-in + "
-        f"{plugin_count} plugin modules = {total_count} modules, "
-        f"{total_registered} tools registered"
-    )
-
-    return total_count
-
-
 def list_registered_tools() -> List[str]:
     """List names of all registered tools.
 

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.
@@ -109,7 +160,7 @@ class PathResolver:
 
             # Step 2b: Security boundary — path must be within repo_root, vault_path,
             # or the agent's own data directory (~/.bone/).
-            if enforce_boundary:
+            if enforce_boundary and not _full_filesystem_access:
                 try:
                     path.relative_to(self.repo_root)
                 except ValueError:
@@ -125,12 +176,12 @@ class PathResolver:
                                 elapsed = time.time() - start_time
                                 _track_validation_error("outside_allowed_roots")
                                 _path_resolution_times.append(elapsed)
-                                return None, f"Path is outside allowed directories: {path_str}"
+                                return None, f"{_BOUNDARY_ERROR_PREFIXES[0]} {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: