bone-agent 1.4.0 → 2.0.0

package/src/tools/helpers/plugin_manifest.py

@@ -1,185 +0,0 @@
-"""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
-activated via the search_plugins core tool.
-"""
-
-import logging
-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 and stored skills for discovery surfaces.
-
-    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):
-        self._plugins: Dict[str, ToolDefinition] = {}
-
-    def register(self, tool_def: ToolDefinition) -> None:
-        """Register a plugin tool definition.
-
-        Args:
-            tool_def: ToolDefinition with tier="plugin"
-        """
-        if tool_def.name in self._plugins:
-            logger.warning(
-                f"Plugin '{tool_def.name}' is being overwritten. "
-                f"Previous: {self._plugins[tool_def.name].handler}, "
-                f"New: {tool_def.handler}"
-            )
-        self._plugins[tool_def.name] = tool_def
-        logger.debug(f"Plugin registered in manifest: {tool_def.name}")
-
-    def get(self, name: str) -> Optional[ToolDefinition]:
-        """Get a plugin tool definition by name.
-
-        Args:
-            name: Plugin tool name
-
-        Returns:
-            ToolDefinition or None if not found
-        """
-        return self._plugins.get(name)
-
-    def get_all(self) -> List[ToolDefinition]:
-        """Get all registered plugin definitions.
-
-        Returns:
-            List of all ToolDefinitions in the manifest
-        """
-        return list(self._plugins.values())
-
-    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.
-
-        Returns:
-            Sorted list of category strings
-        """
-        categories = {td.category for td in self._plugins.values() if td.category}
-        return sorted(categories)
-
-    def plugin_count(self) -> int:
-        """Get the number of registered plugins.
-
-        Returns:
-            Number of plugins in the manifest
-        """
-        return len(self._plugins)
-
-    def has_plugin(self, name: str) -> bool:
-        """Check if a plugin exists in the manifest.
-
-        Args:
-            name: Plugin tool name
-
-        Returns:
-            True if plugin is in the manifest
-        """
-        return name in self._plugins
-
-
-# Singleton instance
-plugin_manifest = PluginManifest()

package/src/tools/obsidian.py

@@ -1,96 +0,0 @@
-"""Obsidian vault integration utilities.
-
-Provides vault session management for project note routing.
-"""
-
-import logging
-import os
-from pathlib import Path
-from dataclasses import dataclass
-from typing import Optional
-
-logger = logging.getLogger(__name__)
-
-
-@dataclass(frozen=True)
-class VaultSession:
-    """Immutable snapshot of vault pairing state.
-
-    Built once when the vault is activated (register()) and shared everywhere.
-    Eliminates scattered derivation of vault_root, project_folder, and path prefixes.
-
-    Attributes:
-        vault_root: Absolute validated vault root Path.
-        project_folder: Absolute project folder (vault_root / project_base / repo_name).
-        project_folder_relative: Vault-relative project folder string (e.g. "Dev/myrepo").
-    """
-    vault_root: Path
-    project_folder: Path
-    project_folder_relative: str
-
-
-# Module-level session — set by register(), cleared by unregister()
-_session: Optional[VaultSession] = None
-
-
-def get_vault_session() -> Optional[VaultSession]:
-    """Return the active VaultSession, or None if vault is not paired."""
-    return _session
-
-
-def build_vault_session(repo_root: Path = None) -> Optional[VaultSession]:
-    """Build a VaultSession from current settings.
-
-    Args:
-        repo_root: Repository root used to derive project folder name.
-                   Falls back to os.getcwd() if not provided.
-
-    Returns:
-        VaultSession if vault is configured and valid, None otherwise.
-    """
-    from utils.settings import obsidian_settings
-
-    if not obsidian_settings.is_active():
-        return None
-
-    root = obsidian_settings.vault_path  # Already validated by is_active()
-    # Re-resolve to absolute (is_active checks existence but returns raw string)
-    root = Path(root).resolve()
-
-    project_base = obsidian_settings.project_base or "Dev"
-    repo_name = repo_root.name if repo_root else os.path.basename(os.getcwd())
-    if not repo_name:
-        return None
-
-    project_folder = root / project_base / repo_name
-    pf_relative = str(project_base) + "/" + repo_name
-
-    return VaultSession(
-        vault_root=root,
-        project_folder=project_folder,
-        project_folder_relative=pf_relative,
-    )
-
-
-def init_session(repo_root: Path = None) -> Optional[VaultSession]:
-    """Build and cache the VaultSession.
-
-    Should be called once with the actual repo_root when available.
-    Falls back to os.getcwd() if repo_root is None (acceptable for prompt
-    building before the orchestrator starts).
-
-    Returns:
-        The active VaultSession, or None if vault is not configured.
-    """
-    global _session
-    session = build_vault_session(repo_root=repo_root)
-    if session:
-        # Only cache if we have a real repo_root — otherwise the orchestrator
-        # will call us again with the correct path and that should win.
-        if repo_root is not None or _session is None:
-            _session = session
-            logger.info(f"Vault session initialized: {session.project_folder_relative}")
-    return _session
-
-
-

package/src/tools/review_sub_agent.py

@@ -1,190 +0,0 @@
-"""Review sub-agent tool for analyzing git diffs."""
-
-import re
-from pathlib import Path
-
-from core.sub_agent import run_sub_agent
-from tools.sub_agent import SimplePanelUpdater
-from utils.citation_parser import inject_file_contents
-
-# Approximate chars per token (conservative heuristic, avoids tokenizer dependency)
-_CHARS_PER_TOKEN = 4
-
-# Max tokens for the diff context (leaves room for agent conversation within budget)
-_MAX_DIFF_TOKENS = 50_000
-
-
-def _estimate_tokens(text: str) -> int:
-    """Rough token estimate based on character count."""
-    return len(text) // _CHARS_PER_TOKEN
-
-
-def _truncate_diff(diff: str, max_chars: int) -> tuple:
-    """Truncate a diff to fit within a character budget, keeping whole files.
-
-    Returns:
-        Tuple of (truncated_diff, list_of_skipped_file_names)
-    """
-    # Split on diff headers: each file starts with "diff --git"
-    file_blocks = re.split(r'(?=^diff --git )', diff, flags=re.MULTILINE)
-    # First element may be empty if diff starts with "diff --git"
-    if file_blocks and file_blocks[0].strip() == '':
-        file_blocks = file_blocks[1:]
-
-    result_blocks = []
-    skipped_files = []
-    current_chars = 0
-
-    for block in file_blocks:
-        block_chars = len(block)
-        if current_chars + block_chars > max_chars:
-            # Extract file name from the block header for the skip list
-            match = re.search(r'^diff --git a/(.*?) b/', block, re.MULTILINE)
-            if match:
-                skipped_files.append(match.group(1))
-        else:
-            result_blocks.append(block)
-            current_chars += block_chars
-
-    truncated = '\n'.join(result_blocks)
-    return truncated, skipped_files
-
-
-def _count_binary_files(diff: str) -> int:
-    """Count binary file entries in a diff."""
-    return len(re.findall(r'^Binary files ', diff, re.MULTILINE))
-
-
-def _build_review_context(diff: str) -> str:
-    """Build the initial context message for the review sub-agent.
-
-    Handles truncation and binary file counting.
-
-    Returns:
-        Tuple of (context_string, warning_string_or_None)
-    """
-    warning = None
-    max_chars = _MAX_DIFF_TOKENS * _CHARS_PER_TOKEN
-
-    # Check for binary files
-    binary_count = _count_binary_files(diff)
-    binary_note = ""
-    if binary_count > 0:
-        binary_note = f"\n\nNote: {binary_count} binary file(s) were skipped in this diff."
-
-    # Check if truncation is needed
-    estimated_tokens = _estimate_tokens(diff)
-    if estimated_tokens > _MAX_DIFF_TOKENS:
-        truncated_diff, skipped_files = _truncate_diff(diff, max_chars)
-        skipped_note = ""
-        if skipped_files:
-            skipped_note = (
-                f"\n\nWARNING: Diff was too large and has been truncated. "
-                f"The following {len(skipped_files)} file(s) were omitted from review:\n"
-                + "\n".join(f"  - {f}" for f in skipped_files)
-            )
-        warning = f"Diff truncated: {len(skipped_files)} file(s) omitted."
-        context = f"Review this git diff:\n\n{truncated_diff}{binary_note}{skipped_note}"
-    else:
-        context = f"Review this git diff:\n\n{diff}{binary_note}"
-
-    return context, warning
-
-
-def review_changes(
-    diff_output: str,
-    repo_root: Path,
-    rg_exe_path: str,
-    console,
-    chat_manager,
-    gitignore_spec=None,
-    panel_updater=None,
-    user_intent: str = None,
-) -> dict:
-    """Run review sub-agent on a git diff.
-
-    Args:
-        diff_output: Git diff string to review
-        repo_root: Repository root directory
-        rg_exe_path: Path to rg executable
-        console: Rich console for output
-        chat_manager: ChatManager instance
-        gitignore_spec: PathSpec for .gitignore filtering
-        panel_updater: Optional SubAgentPanel for live updates
-        user_intent: Optional description of what the user was trying to do
-
-    Returns:
-        Dict with keys:
-            display: Clean review text (no injected file contents)
-            history: Review text with file contents injected from citations
-    """
-    if not diff_output or not isinstance(diff_output, str) or not diff_output.strip():
-        result = "No changes to review."
-        return {"display": result, "history": result}
-
-    # Build context (handles truncation and binary file notes)
-    review_context, truncation_warning = _build_review_context(diff_output)
-
-    if truncation_warning:
-        console.print(f"[yellow]{truncation_warning}[/yellow]")
-
-    # Set up panel updater
-    if panel_updater is None:
-        panel_updater = SimplePanelUpdater(console)
-
-    # Task query for the review agent
-    if user_intent:
-        task_query = (
-            "Analyze the diff provided above. "
-            "For each changed file, use read_file to get surrounding context. "
-            "Then provide a structured code review with findings, issues, and suggestions.\n\n"
-            f"The user's intent for these changes was: {user_intent}\n"
-            "Use this context to better understand the changes and focus your review accordingly."
-        )
-    else:
-        task_query = (
-            "Analyze the diff provided above. "
-            "For each changed file, use read_file to get surrounding context. "
-            "Then provide a structured code review with findings, issues, and suggestions."
-        )
-
-    with panel_updater as panel:
-        sub_agent_data = run_sub_agent(
-            task_query=task_query,
-            repo_root=repo_root,
-            rg_exe_path=rg_exe_path,
-            console=console,
-            panel_updater=panel,
-            sub_agent_type="review",
-            initial_context=review_context,
-        )
-
-        # Check for errors
-        if sub_agent_data.get('error'):
-            panel.set_error(sub_agent_data['error'])
-            result = f"exit_code=1\n{sub_agent_data['error']}"
-            return {"display": result, "history": result}
-
-        # Track usage
-        usage = sub_agent_data.get('usage', {})
-        if usage:
-            chat_manager.token_tracker.add_usage(usage, model_name=sub_agent_data.get("model", ""))
-            panel.set_complete({
-                'prompt_tokens': usage.get('prompt_tokens', 0),
-                'completion_tokens': usage.get('completion_tokens', 0),
-                'total_tokens': usage.get('total_tokens', 0),
-                'context_tokens': usage.get('context_tokens', 0),
-            })
-
-        raw_result = sub_agent_data.get('result', '')
-
-        # If hard limit was exceeded, skip injection and return raw dump for both
-        if sub_agent_data.get('hard_limit_exceeded'):
-            return {"display": raw_result, "history": raw_result}
-
-        # Always inject file contents from citations into the history version
-        injected_result = inject_file_contents(
-            raw_result, repo_root, gitignore_spec, console
-        )
-
-        return {"display": raw_result, "history": injected_result}