bone-agent 1.3.3 → 2.0.0

package/src/tools/helpers/plugin_manifest.py

@@ -1,156 +0,0 @@
-"""Plugin manifest for on-demand tool 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 typing import Dict, List, Optional
-
-from .base import ToolDefinition
-
-logger = logging.getLogger(__name__)
-
-
-class PluginManifest:
-    """Index of plugin-tier tools available for on-demand activation.
-
-    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.
-    """
-
-    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 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 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,189 +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)
-            })
-
-        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}