bone-agent 1.4.0 → 2.0.1

package/src/utils/gitignore_filter.py

@@ -1,149 +0,0 @@
-"""Centralized .gitignore filtering using pathspec library."""
-
-import logging
-from pathlib import Path
-from typing import Optional, Tuple
-
-logger = logging.getLogger(__name__)
-
-# Always allow .gitignore itself to be read/edited
-ALWAYS_ALLOWED_FILES = {".gitignore"}
-
-# Try to import pathspec at module level
-try:
-    import pathspec
-except ImportError:
-    pathspec = None
-    logger.warning("pathspec library not installed - .gitignore filtering disabled")
-
-
-def load_gitignore_spec(repo_root: Path):
-    """Load .gitignore patterns into a PathSpec object.
-
-    Args:
-        repo_root: Repository root directory
-
-    Returns:
-        pathspec.PathSpec or None if .gitignore doesn't exist
-    """
-    # Return None early if pathspec is not available
-    if pathspec is None:
-        return None
-
-    gitignore_path = repo_root / ".gitignore"
-
-    if not gitignore_path.exists():
-        return None
-
-    try:
-        # Read .gitignore patterns
-        patterns = gitignore_path.read_text(encoding="utf-8").splitlines()
-
-        # Create PathSpec with gitwildmatch (git's pattern matching)
-        spec = pathspec.PathSpec.from_lines("gitwildmatch", patterns)
-        return spec
-
-    except Exception as e:
-        logger.warning(f"Failed to load .gitignore: {e}")
-        return None
-
-
-def is_path_ignored(
-    path: Path, repo_root: Path, gitignore_spec
-) -> Tuple[bool, Optional[str]]:
-    """Check if a path is ignored by .gitignore.
-
-    Args:
-        path: Absolute path to check
-        repo_root: Repository root directory
-        gitignore_spec: pathspec.PathSpec object (or None)
-
-    Returns:
-        Tuple of (is_ignored, matched_pattern)
-        - is_ignored: True if path should be blocked
-        - matched_pattern: The pattern that matched (or None)
-    """
-    # No filtering if no .gitignore
-    if gitignore_spec is None:
-        return False, None
-
-    # Always allow .gitignore itself
-    if path.name in ALWAYS_ALLOWED_FILES:
-        return False, None
-
-    # Get relative path from repo root (gitignore only applies within repo)
-    try:
-        rel_path = path.relative_to(repo_root)
-    except ValueError:
-        # Path is outside repo - gitignore doesn't apply
-        return False, None
-
-    # Convert to forward slashes (git convention)
-    rel_path_str = str(rel_path).replace("\\", "/")
-
-    # Check if path matches any .gitignore pattern
-    # pathspec.match_file() returns True if the file should be ignored
-    if gitignore_spec.match_file(rel_path_str):
-        # Find which pattern matched (for better error messages)
-        matched_pattern = _find_matching_pattern(rel_path_str, gitignore_spec)
-        return True, matched_pattern
-
-    return False, None
-
-
-def _find_matching_pattern(path_str: str, gitignore_spec) -> Optional[str]:
-    """Find which .gitignore pattern matched a path.
-
-    This is for better error messages.
-
-    Args:
-        path_str: Relative path string (with forward slashes)
-        gitignore_spec: pathspec.PathSpec object
-
-    Returns:
-        The matching pattern string, or None
-    """
-    try:
-        # PathSpec stores patterns internally
-        for pattern in gitignore_spec.patterns:
-            if pattern.match_file(path_str):
-                # Return the original pattern string
-                return pattern.pattern
-    except Exception:
-        pass
-
-    return None
-
-
-def format_gitignore_error(
-    path: Path, repo_root: Path, matched_pattern: Optional[str]
-) -> str:
-    """Format a user-friendly error message for .gitignore blocked files.
-
-    Args:
-        path: The blocked file path
-        repo_root: Repository root
-        matched_pattern: The .gitignore pattern that matched
-
-    Returns:
-        Formatted error message
-    """
-    try:
-        rel_path = path.relative_to(repo_root)
-    except ValueError:
-        rel_path = path
-
-    error_msg = (
-        f"exit_code=ERROR_GITIGNORE_BLOCKED\n"
-        f"File blocked by .gitignore: {rel_path}\n\n"
-    )
-    error_msg += "This file matches patterns in .gitignore and cannot be accessed.\n"
-
-    if matched_pattern:
-        error_msg += f"Matched pattern: {matched_pattern}\n"
-
-    error_msg += "\nTo access this file:\n"
-    error_msg += "1. Remove it from .gitignore, or\n"
-    error_msg += "2. Use git commands directly (git show, git diff)\n"
-
-    return error_msg

package/src/utils/logger.py

@@ -1,254 +0,0 @@
-"""Markdown conversation logging module for saving chat history to readable markdown files."""
-
-import json
-import logging
-from datetime import datetime
-from pathlib import Path
-from typing import Optional, Dict, Any, List
-
-logger = logging.getLogger(__name__)
-
-
-class MarkdownConversationLogger:
-    """Logs conversations to Markdown format with tool call details."""
-
-    MAX_CONTENT_LENGTH = 2000
-
-    def __init__(self, conversations_dir: str = "conversations"):
-        """Initialize markdown conversation logger.
-
-        Args:
-            conversations_dir: Directory to save conversation logs
-        """
-        self.conversations_dir = Path(conversations_dir)
-        self.conversations_dir.mkdir(exist_ok=True)
-        self.current_file: Optional[Path] = None
-
-    def start_session(self):
-        """Start a new conversation session."""
-        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-        self.current_file = self.conversations_dir / f"conversation_{timestamp}.md"
-        logger.info(f"Started markdown conversation logging to {self.current_file}")
-
-        # Write header
-        with open(self.current_file, 'w', encoding='utf-8') as f:
-            f.write(f"# Conversation Log\n\n")
-            f.write(f"**Started:** {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n\n")
-            f.write("---\n\n")
-
-    def _format_tool_call(self, tool_call: Dict[str, Any]) -> str:
-        """Format a tool call for markdown display.
-
-        Args:
-            tool_call: Tool call dict with id, type, function
-
-        Returns:
-            Formatted markdown string
-        """
-        fn = tool_call.get("function", {})
-        name = fn.get("name", "unknown")
-        arguments = fn.get("arguments", "{}")
-        args_str = self._format_json_value(arguments)
-
-        return f"""### {name}
-
-```json
-{args_str}
-```"""
-
-    def _format_json_value(self, value: Any) -> str:
-        """Format a value as JSON for markdown display.
-
-        Args:
-            value: Value to format (string, dict, or other)
-
-        Returns:
-            Formatted JSON string, or string representation if not JSON-serializable
-        """
-        try:
-            if isinstance(value, str):
-                parsed = json.loads(value)
-            else:
-                parsed = value
-            return json.dumps(parsed, indent=2, ensure_ascii=False)
-        except (json.JSONDecodeError, TypeError):
-            return str(value)
-
-    def _format_tool_call_inline(self, arguments: Any) -> str:
-        """Format tool call arguments as JSON for inline display.
-
-        Args:
-            arguments: Tool call arguments (string or dict)
-
-        Returns:
-            Formatted JSON string
-        """
-        args_str = self._format_json_value(arguments)
-        return f"```json\n{args_str}\n```"
-
-    def _format_tool_result(self, message: Dict[str, Any]) -> str:
-        """Format a tool result for markdown display.
-
-        Args:
-            message: Tool result message with role, tool_call_id, content
-
-        Returns:
-            Formatted markdown string
-        """
-        content = message.get("content", "")
-
-        # Truncate very long outputs
-        if len(content) > self.MAX_CONTENT_LENGTH:
-            content = content[:self.MAX_CONTENT_LENGTH] + "\n\n... (truncated)"
-
-        # Try to format as code if it looks like structured output
-        if content and (content.startswith("{") or content.startswith("[")):
-            try:
-                parsed = json.loads(content)
-                content = json.dumps(parsed, indent=2, ensure_ascii=False)
-                return f"```\n{content}\n```\n"
-            except json.JSONDecodeError:
-                pass
-
-        return f"```\n{content}\n```\n"
-
-    def _format_message(self, message: Dict[str, Any], skip_tool_calls: bool = False) -> str:
-        """Convert a message dict to markdown format.
-
-        Args:
-            message: Message dict with role, content, tool_calls, etc.
-            skip_tool_calls: If True, don't include tool_calls section
-
-        Returns:
-            Formatted markdown string
-        """
-        role = message.get("role", "unknown")
-        content = message.get("content", "")
-
-        if role == "user":
-            emoji = "👤"
-            title = "User"
-        elif role == "assistant":
-            emoji = "🤖"
-            title = "Assistant"
-        elif role == "tool":
-            # Tool results are handled separately with their tool calls
-            return None
-        elif role == "system":
-            emoji = "⚙️"
-            title = "System"
-        else:
-            emoji = "📝"
-            title = role.capitalize()
-
-        md = f"\n## {emoji} {title}\n\n"
-
-        # Add content if present
-        if content:
-            md += f"{content}\n\n"
-
-        # Add tool calls if present (skip when skip_tool_calls=True)
-        if not skip_tool_calls and message.get("tool_calls"):
-            md += "### 🔧 Tool Calls\n\n"
-            for tc in message["tool_calls"]:
-                md += self._format_tool_call(tc) + "\n"
-
-        return md
-
-    def log_message(self, message: Dict[str, Any]):
-        """Append a message to the current markdown file.
-
-        Args:
-            message: Message dict with 'role' and 'content' keys, optionally 'tool_calls'
-        """
-        if not self.current_file:
-            self.start_session()
-
-        # Check if this is a tool result - we'll handle it differently
-        if message.get("role") == "tool":
-            # Find the associated tool call by tool_call_id
-            tool_call_id = message.get("tool_call_id")
-            formatted = f"\n### 📋 Tool Result (ID: `{tool_call_id}`)\n\n"
-            formatted += self._format_tool_result(message) + "\n"
-        else:
-            formatted = self._format_message(message)
-
-        if formatted:
-            with open(self.current_file, 'a', encoding='utf-8') as f:
-                f.write(formatted)
-
-    def rewrite_log(self, messages: List[Dict[str, Any]]):
-        """Rewrite the current markdown log to match the provided messages.
-
-        Args:
-            messages: Full message list to persist
-        """
-        if not self.current_file:
-            self.start_session()
-
-        # Rewrite entire file
-        with open(self.current_file, 'w', encoding='utf-8') as f:
-            # Write header
-            f.write(f"# Conversation Log\n\n")
-            f.write(f"**Started:** {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n\n")
-            f.write(f"**Last Updated:** {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n\n")
-            f.write("---\n\n")
-
-            # Track tool calls to pair with results
-            pending_tool_calls = {}
-
-            for message in messages:
-                role = message.get("role")
-
-                if role == "assistant" and message.get("tool_calls"):
-                    # Store tool calls for later pairing with results
-                    for tc in message["tool_calls"]:
-                        pending_tool_calls[tc["id"]] = tc
-
-                    # Write the assistant message (skip tool_calls section)
-                    formatted = self._format_message(message, skip_tool_calls=True)
-                    if formatted:
-                        f.write(formatted)
-
-                elif role == "tool":
-                    # This is a tool result, pair it with the call
-                    tool_call_id = message.get("tool_call_id")
-                    tc = pending_tool_calls.get(tool_call_id)
-
-                    if tc:
-                        # Write tool call with result together
-                        fn = tc.get("function", {})
-                        name = fn.get("name", "unknown")
-                        arguments = fn.get("arguments", "{}")
-
-                        f.write(f"\n### 🔧 Tool Call: {name}\n\n")
-                        f.write(self._format_tool_call_inline(arguments) + "\n\n")
-                        f.write(f"**Result:**\n\n")
-                    else:
-                        # Orphaned result (no matching call)
-                        f.write(f"\n### 🔧 Tool Result (ID: `{tool_call_id}`)\n\n")
-
-                    f.write(self._format_tool_result(message) + "\n")
-
-                else:
-                    # Regular message (user, system)
-                    formatted = self._format_message(message)
-                    if formatted:
-                        f.write(formatted)
-
-            # Write footer
-            f.write("\n---\n\n")
-            f.write(f"*End of conversation*\n")
-
-    def end_session(self):
-        """End the current conversation logging session."""
-        if not self.current_file:
-            return
-
-        # Add footer
-        with open(self.current_file, 'a', encoding='utf-8') as f:
-            f.write("\n---\n\n")
-            f.write(f"**Ended:** {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n")
-
-        logger.info(f"Ended markdown conversation session: {self.current_file.name}")
-        self.current_file = None

package/src/utils/paths.py

@@ -1,30 +0,0 @@
-"""Shared path constants for bone-agent.
-
-Centralizes APP_ROOT, REPO_ROOT, and tool paths (e.g. ripgrep)
-so they can be imported from both core and ui modules without
-creating circular dependencies.
-"""
-
-import os
-import sys
-from pathlib import Path
-
-
-def _resolve_app_root() -> Path:
-    """Return the application root directory.
-
-    For frozen builds (PyInstaller), this is the directory containing
-    the executable. For source installs, it's two levels up from this file
-    (i.e. the repo root).
-    """
-    if getattr(sys, "frozen", False):
-        return Path(sys.executable).resolve().parent
-    return Path(__file__).resolve().parents[2]
-
-
-APP_ROOT = _resolve_app_root()
-REPO_ROOT = Path.cwd().resolve()
-
-# Platform-agnostic ripgrep path: 'rg' on Unix/Linux, 'rg.exe' on Windows
-_RG_EXE_NAME = "rg.exe" if os.name == "nt" else "rg"
-RG_EXE_PATH = (APP_ROOT / "bin" / _RG_EXE_NAME).resolve()

package/src/utils/result_parsers.py

@@ -1,108 +0,0 @@
-"""Result parsing utilities for tool outputs."""
-
-from typing import Optional
-
-
-def extract_exit_code(tool_result: str) -> Optional[int]:
-    """Parse exit_code from tool result string.
-
-    Args:
-        tool_result: Tool result content string
-
-    Returns:
-        Exit code as integer, or None if not found
-    """
-    if not isinstance(tool_result, str):
-        return None
-    first_line = tool_result.splitlines()[0] if tool_result else ""
-    if first_line.startswith("exit_code="):
-        try:
-            value = first_line.split("=", 1)[1].strip()
-            value = value.split()[0] if value else value
-            return int(value)
-        except ValueError:
-            return None
-    return None
-
-
-def extract_metadata_from_result(tool_result: str, key: str) -> Optional[int]:
-    """Parse metadata like matches_found, lines_read, etc. from tool result.
-
-    Args:
-        tool_result: Tool result content string
-        key: Metadata key to extract (e.g., "matches_found", "lines_read")
-
-    Returns:
-        Extracted value as int, or None if not found
-    """
-    if not isinstance(tool_result, str):
-        return None
-    for line in tool_result.split('\n'):
-        if line.startswith(f'{key}='):
-            try:
-                return int(line.split('=')[1].split()[0])
-            except (ValueError, IndexError):
-                return None
-    return None
-
-
-def extract_all_metadata(tool_result: str, line_index: int = 0) -> dict:
-    """Parse entire metadata line into a dictionary.
-
-    Parses space-separated key=value pairs from a specific line.
-    Follows format defined in src/tools/helpers/formatters.py.
-
-    Args:
-        tool_result: Tool result string
-        line_index: Which line to parse (default: 0, use 1 for rg results)
-
-    Returns:
-        dict with all parsed metadata (e.g., {'exit_code': 0, 'lines_read': 123, ...})
-        Returns empty dict if tool_result is invalid or line_index out of range
-    """
-    if not isinstance(tool_result, str) or not tool_result:
-        return {}
-
-    lines = tool_result.split('\n')
-    if line_index >= len(lines):
-        return {}
-
-    line = lines[line_index].strip()
-    if not line:
-        return {}
-
-    metadata = {}
-    # Parse: exit_code=0 path=file.py lines_read=123 start_line=1
-    for pair in line.split():
-        if '=' in pair:
-            key, value = pair.split('=', 1)
-            # Skip empty values
-            if not value:
-                continue
-            # Try to parse as int, keep as string if fails
-            try:
-                value = int(value)
-            except ValueError:
-                # Keep as string (e.g., paths, error messages)
-                pass
-            metadata[key] = value
-
-    return metadata
-
-
-def extract_multiple_metadata(tool_result: str, *keys: str, line_index: int = 0) -> dict:
-    """Extract specific metadata keys from a tool result line.
-
-    Args:
-        tool_result: Tool result string
-        *keys: Metadata keys to extract (e.g., 'lines_read', 'start_line')
-        line_index: Which line to parse (default: 0)
-
-    Returns:
-        dict mapping keys to their parsed values
-        Missing keys are not included in the result
-    """
-    all_metadata = extract_all_metadata(tool_result, line_index=line_index)
-
-    # Return only requested keys that exist
-    return {key: all_metadata[key] for key in keys if key in all_metadata}