bone-agent 1.3.3 → 1.4.0

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

@@ -5,7 +5,7 @@ import re
 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
@@ -83,7 +83,7 @@ def _annotate_file_sizes(formatted_output: str, base_path: Path, output_mode: st
 
 @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": {
@@ -93,7 +93,12 @@ def _annotate_file_sizes(formatted_output: str, base_path: Path, output_mode: st
             },
             "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",
@@ -138,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,
@@ -153,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)
@@ -204,11 +211,21 @@ def rg(
     elif output_mode == "count":
         args.append("--count")
 
-    # Pattern and search path — no quoting needed, subprocess list form bypasses shell
+    # Pattern and search paths — no quoting needed, subprocess list form bypasses shell
     args.append(pattern)
 
-    search_path = path or "."
-    args.append(search_path)
+    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:
+        search_paths = [path or "."]
+
+    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

package/src/tools/search_plugins.py

@@ -1,38 +1,41 @@
-"""search_plugins core tool for on-demand plugin discovery.
+"""search_plugins core tool for on-demand capability discovery.
 
 This tool lets the LLM agent search for available plugin tools and
-activate them. Plugin schemas are not sent by default to avoid context
-bloat — they are only included after activation.
+stored skills, then explicitly activate plugins or load skills through
+the same entrypoint. Plugin schemas are not sent by default to avoid
+context bloat — they are only included after activation.
 """
 
-from typing import List, Optional
-from pathlib import Path
-
 from tools.helpers.base import tool, ToolRegistry, TERMINAL_NONE
 
+HEADER_MATCHES = "Capability matches for: "
+HEADER_ALL = "All available capabilities"
+
 
 @tool(
     name="search_plugins",
     description=(
-        "Search for available plugin tools that can help with your task. "
-        "Plugin tools are NOT in your available tools by default — use this "
-        "to discover and activate them. Returns matching plugin names and "
-        "descriptions. Once activated, the plugin's full schema will be "
-        "available in your next response."
+        "Search for available plugin tools and saved skills that can help "
+        "with your task. Plugins are NOT in your available tools by default "
+        "— use this to discover and activate them. Skills can also be loaded "
+        "through this same tool by passing explicit capability names in 'load'. "
+        "Once a plugin is activated, its full schema will be available in your "
+        "next response."
     ),
     parameters={
         "type": "object",
         "properties": {
             "query": {
                 "type": "string",
-                "description": "Search query describing what you need (e.g., 'send email', 'query database', 'http request')"
+                "description": "Search query describing what you need (e.g., 'send email', 'query database', 'http request'). Omit to list all available plugins and skills."
             },
-            "category": {
-                "type": "string",
-                "description": "Optional category filter (e.g., 'email', 'database', 'analysis')"
+            "load": {
+                "type": "array",
+                "items": {"type": "string"},
+                "description": "Optional list of exact capability names from the current search results to activate or load. Plugins are activated; skills are injected into the current chat."
             }
         },
-        "required": ["query"]
+        "required": []
     },
     requires_approval=False,
     terminal_policy=TERMINAL_NONE,
@@ -41,69 +44,134 @@ from tools.helpers.base import tool, ToolRegistry, TERMINAL_NONE
     category="core"
 )
 def search_plugins(
-    query: str,
-    category: str = None,
+    query: str = "",
+    load: list[str] | None = None,
+    chat_manager=None,
 ) -> str:
-    """Search the plugin manifest and activate matching plugins.
-
-    Args:
-        query: Search query describing the needed capability
-        category: Optional category filter
+    """Search discoverable capabilities and optionally activate/load selected matches.
 
-    Returns:
-        Formatted result with activated plugin names and descriptions
-    """
+    When using `load`, `query` must be provided so selections come from the current search results."""
+    from core.skills import SkillError, activate_skill, validate_skill_name
     from tools.helpers.plugin_manifest import plugin_manifest
 
-    # Check if any core tool matches the query — early return
     core_tools = ToolRegistry.get_all(include_plugins=False)
-    query_lower = query.lower()
-    for ct in core_tools:
-        if query_lower == ct.name.lower() or query_lower in ct.name.lower():
-            return (
-                f"exit_code=0\n"
-                f"'{query}' matches a core tool that is already available: **{ct.name}**.\n"
-                f"Description: {ct.description}"
-            )
-
-    # Search the plugin manifest
-    matches = plugin_manifest.search(query, category=category, max_results=5)
+    core_tool_note = None
+    query = query.strip()
+
+    if load and not query:
+        return "\n".join([
+            "exit_code=1",
+            "Loading capabilities requires a query so selections come from the current search results.",
+        ])
+
+    # No query → list everything
+    if not query:
+        matches = plugin_manifest.list_all_capabilities()
+    else:
+        query_lower = query.lower()
+        for ct in core_tools:
+            if query_lower == ct.name.lower():
+                core_tool_note = (
+                    f"Core tool already available: {ct.name}\n"
+                    f"  {ct.description}"
+                )
+                break
+
+        matches = plugin_manifest.search_capabilities(query, max_results=10)
 
     if not matches:
-        # No matches — suggest available categories
-        categories = plugin_manifest.get_categories()
-        if categories:
-            cat_list = ", ".join(f"'{c}'" for c in categories)
-            return (
-                f"exit_code=0\n"
-                f"No plugins found matching '{query}'.\n"
-                f"Available plugin categories: {cat_list}\n"
-                f"Total plugins in manifest: {plugin_manifest.plugin_count()}"
-            )
-        return (
-            f"exit_code=0\n"
-            f"No plugins found matching '{query}'. "
-            f"No plugins are currently registered in the manifest."
-        )
-
-    # Activate matched plugins in the registry
-    activated = []
-    already_active = []
-    for tool_def in matches:
-        if ToolRegistry.is_plugin_active(tool_def.name):
-            already_active.append(tool_def.name)
+        lines = ["exit_code=0"]
+        if core_tool_note:
+            lines.extend([core_tool_note, ""])
+        if query:
+            lines.append(f"No matches for: {query}")
         else:
-            ToolRegistry.activate_plugin(tool_def)
-            activated.append(tool_def.name)
-
-    # Build result
-    lines = [f"exit_code=0\nFound {len(matches)} plugin(s) matching '{query}':\n"]
-
-    for tool_def in matches:
-        status = "activated" if tool_def.name in activated else "already active"
-        cat_part = f" [{tool_def.category}]" if tool_def.category else ""
-        lines.append(f"- **{tool_def.name}**{cat_part} ({status}): {tool_def.description}")
-        if tool_def.tags:
-            lines.append(f"  Tags: {', '.join(tool_def.tags)}")
+            lines.append("No plugins or skills available.")
+        return "\n".join(lines)
+
+    requested = [name for name in (load or []) if isinstance(name, str) and name.strip()]
+    requested_normalized = {name.strip().lower(): name.strip() for name in requested}
+    matched_by_name = {match.name.lower(): match for match in matches}
+
+    plugin_count = 0
+    skill_count = 0
+    loaded_plugins = []
+    loaded_skills = []
+    load_errors = []
+
+    for match in matches:
+        if match.kind == "plugin" and match.tool_def:
+            plugin_count += 1
+            if ToolRegistry.is_plugin_active(match.tool_def.name):
+                match.already_active = True
+            if match.name.lower() in requested_normalized and not match.already_active:
+                if ToolRegistry.activate_plugin(match.tool_def):
+                    match.activated = True
+                    loaded_plugins.append(match.name)
+                else:
+                    load_errors.append(f"Plugin '{match.name}' is disabled. Enable it before loading.")
+            continue
+        skill_count += 1
+        if match.name.lower() in requested_normalized:
+            if chat_manager is None:
+                load_errors.append(f"Skill '{match.name}' cannot be loaded without an active chat.")
+                continue
+            try:
+                skill_name = validate_skill_name(match.name)
+                activate_skill(chat_manager, skill_name)
+                loaded_skills.append(skill_name)
+            except SkillError as exc:
+                load_errors.append(str(exc))
+
+    missing_requested = [
+        original_name
+        for normalized_name, original_name in requested_normalized.items()
+        if normalized_name not in matched_by_name
+    ]
+    for missing in missing_requested:
+        load_errors.append(f"Capability '{missing}' was not found in the current search results.")
+
+    lines = ["exit_code=0"]
+    if core_tool_note:
+        lines.extend([core_tool_note, ""])
+
+    if query:
+        lines.extend([
+            f"{HEADER_MATCHES}{query}",
+            f"Results: {len(matches)} total ({plugin_count} plugin, {skill_count} skill)",
+            "",
+        ])
+    else:
+        lines.extend([
+            HEADER_ALL,
+            f"Total: {len(matches)} ({plugin_count} plugin, {skill_count} skill)",
+            "",
+        ])
+
+    for match in matches:
+        if match.kind == "plugin":
+            status = "disabled" if ToolRegistry.is_disabled(match.name) else "activated" if match.activated else "active" if match.already_active else "available"
+            lines.append(f"- {match.name}")
+            lines.append("  type: plugin")
+            lines.append(f"  status: {status}")
+            lines.append(f"  summary: {match.description}")
+            if match.tags:
+                lines.append(f"  tags: {', '.join(match.tags)}")
+            continue
+
+        lines.append(f"- {match.name}")
+        lines.append("  type: skill")
+        lines.append(f"  summary: {match.description}")
+        if match.tags:
+            lines.append(f"  tags: {', '.join(match.tags)}")
+
+    if requested:
+        lines.append("")
+        if loaded_plugins:
+            lines.append(f"Activated plugins: {', '.join(loaded_plugins)}")
+        if loaded_skills:
+            lines.append(f"Loaded skills: {', '.join(loaded_skills)}")
+        if load_errors:
+            lines.append(f"Load issues: {'; '.join(load_errors)}")
 
     return "\n".join(lines)

package/src/tools/shell.py

@@ -231,13 +231,13 @@ def run_shell_command(command, repo_root, rg_exe_path, console, debug_mode, giti
 
 @tool(
     name="execute_command",
-    description="Execute shell commands for git, system tasks, file ops, network, and package management. Runs from repo root. Use for git, ps, systemctl, rm, mv, cp, mkdir, ping, curl, wget, ssh, pacman, pip, npm, apt. Disallowed: rg, cat, ls, grep, find, head, tail, sed, awk, sort, uniq, wc, echo, touch, get-content, type, get-childitem, dir, new-item, set-content, add-content, tee. Use native tools instead.",
+    description="Execute shell commands for git, system tasks, file ops, network, and package management. Runs from repo root. Multi-line shell commands are supported and preserved exactly, including heredocs. Use for git, ps, systemctl, rm, mv, cp, mkdir, ping, curl, wget, ssh, pacman, pip, npm, apt. Disallowed: rg, cat, ls, grep, find, head, tail, sed, awk, sort, uniq, wc, echo, touch, get-content, type, get-childitem, dir, new-item, set-content, add-content, tee. Use native tools instead.",
     parameters={
         "type": "object",
         "properties": {
             "command": {
                 "type": "string",
-                "description": "Command to execute"
+                "description": "Shell command to execute from the repo root. May be a single-line command or a multi-line shell script/heredoc; newlines are preserved exactly."
             },
             "reason": {
                 "type": "string",
@@ -262,7 +262,7 @@ def execute_command(
     """Execute a shell command.
 
     Args:
-        command: Command string to execute
+        command: Command string to execute. May contain newlines/heredocs; preserved exactly for shell execution.
         repo_root: Repository root directory (injected by context)
         rg_exe_path: Path to rg executable (injected by context)
         console: Rich console for output (injected by context)