bone-agent 1.4.0 → 2.0.1

package/src/ui/tool_confirmation.py

@@ -1,226 +0,0 @@
-"""Interactive tool confirmation panel with arrow key navigation."""
-
-import asyncio
-from html import escape
-from threading import Timer
-from typing import Optional, Tuple
-from prompt_toolkit import HTML
-from prompt_toolkit.application import Application
-from prompt_toolkit.key_binding import KeyBindings
-from prompt_toolkit.keys import Keys
-from prompt_toolkit.layout import Layout, HSplit, Window
-from prompt_toolkit.layout.controls import FormattedTextControl
-
-
-
-
-class ToolConfirmationPanel:
-    """Interactive panel for tool execution confirmation with arrow key navigation."""
-
-    # Public constants
-    SUMMARY_DISPLAY_DELAY = 0.5  # Seconds to show summary before auto-exit
-    CURSOR = "> "
-    STANDARD_OPTIONS = [
-        {"value": "accept", "text": "Accept"},
-        {"value": "advise", "text": "Advise"},
-        {"value": "cancel", "text": "Cancel"},
-    ]
-    EDIT_OPTIONS = [
-        {"value": "accept", "text": "Accept"},
-        {"value": "accept_all_edits", "text": "Accept All Edits"},
-        {"value": "advise", "text": "Advise"},
-        {"value": "cancel", "text": "Cancel"},
-    ]
-
-    def __init__(self, tool_command: str, reason: Optional[str] = None, is_edit_tool: bool = False, cycle_approve_mode=None):
-        """Initialize the tool confirmation panel.
-
-        Args:
-            tool_command: Command/tool being executed
-            reason: Optional reason/details about the tool execution
-            is_edit_tool: Whether this is an edit tool (shows extra toggle option)
-            cycle_approve_mode: Optional callback to cycle approve_mode
-        """
-        self.tool_command = tool_command
-        self.reason = reason
-        self.is_edit_tool = is_edit_tool
-        self.cycle_approve_mode = cycle_approve_mode
-        self.selected_index = 0
-        self._showing_summary = False
-        self._selected_value = None
-        # Use appropriate options based on tool type
-        self._options = self.EDIT_OPTIONS if is_edit_tool else self.STANDARD_OPTIONS
-
-    def _append_field(self, lines: list[str], label: str, value: object, *, formatted: bool = False) -> None:
-        """Append a field to the panel, escaping untrusted values by default."""
-        value_text = str(value)
-        if not formatted:
-            value_text = escape(value_text)
-        value_lines = value_text.splitlines() or [""]
-        lines.append(f"<b>{escape(label)}:</b> {value_lines[0]}")
-        for continuation in value_lines[1:]:
-            lines.append(f"    {continuation}")
-
-    def _get_display_text(self) -> HTML:
-        """Get the formatted text to display.
-
-        Returns:
-            HTML formatted text with current selection state
-        """
-        lines = []
-
-        # Check if showing summary
-        if self._showing_summary:
-            # Find the option text for the selected value
-            selected_opt = next((opt for opt in self._options if opt.get("value") == self._selected_value), None)
-            selected_text = selected_opt.get("text", self._selected_value) if selected_opt else self._selected_value
-
-            lines.append("<b>Selection Summary</b>")
-            lines.append("")
-            self._append_field(lines, "Tool", self.tool_command)
-            lines.append(f'<style fg="gray">  Selected: {escape(str(selected_text))}</style>')
-            lines.append("")
-        else:
-            # Tool information
-            self._append_field(lines, "Tool", self.tool_command)
-            if self.reason:
-                self._append_field(lines, "Reason", self.reason)
-            lines.append("")
-
-            # Render options
-            for idx, opt in enumerate(self._options):
-                text = opt.get("text", "")
-
-                if idx == self.selected_index:
-                    # Selected option - show cursor and highlight in bold white
-                    lines.append(f'<style fg="white" bold="true">{self.CURSOR}{text}</style>')
-                else:
-                    # Unselected option - dark grey
-                    lines.append(f'<style fg="gray">  {text}</style>')
-
-        return HTML("\n".join(lines))
-
-    def _exit_with_summary(self, event, result: str) -> None:
-        """Show summary screen and exit application after delay.
-
-        Args:
-            event: PromptToolkit event object
-            result: Result value to return when application exits
-        """
-        if self._showing_summary:
-            return
-        self._showing_summary = True
-        self._selected_value = result
-        event.app.invalidate()
-        Timer(self.SUMMARY_DISPLAY_DELAY, lambda: event.app.exit(result=result)).start()
-
-    def _create_key_bindings(self) -> KeyBindings:
-        """Create key bindings for navigation and selection.
-
-        Returns:
-            KeyBindings object with Up/Down/Enter/Esc handlers
-        """
-        bindings = KeyBindings()
-
-        @bindings.add(Keys.Up)
-        def move_up(event):
-            """Move selection up."""
-            if self.selected_index > 0:
-                self.selected_index -= 1
-            event.app.invalidate()
-
-        @bindings.add(Keys.Down)
-        def move_down(event):
-            """Move selection down."""
-            if self.selected_index < len(self._options) - 1:
-                self.selected_index += 1
-            event.app.invalidate()
-
-        @bindings.add(Keys.Enter)
-        def select(event):
-            """Confirm selection."""
-            selected_value = self._options[self.selected_index].get("value")
-            self._selected_value = selected_value
-
-            # Handle accept_all_edits option
-            if selected_value == "accept_all_edits":
-                # Call the callback to cycle approve_mode
-                if self.cycle_approve_mode:
-                    self.cycle_approve_mode()
-                # Return "accept" so the current edit proceeds
-                self._exit_with_summary(event, "accept")
-            else:
-                # Show summary then auto-exit
-                self._exit_with_summary(event, selected_value)
-
-        @bindings.add(Keys.Escape)
-        def cancel(event):
-            """Cancel selection."""
-            self._exit_with_summary(event, "cancel")
-
-        return bindings
-
-    def _create_layout(self) -> Layout:
-        """Create the panel layout.
-
-        Returns:
-            Layout object configured for the confirmation panel
-        """
-        def get_content():
-            return self._get_display_text()
-
-        content_control = FormattedTextControl(get_content)
-
-        root_container = HSplit([
-            Window(content=content_control, height=None),
-        ])
-
-        return Layout(root_container)
-
-    def _handle_result(self, result: str) -> Tuple[str, Optional[str]]:
-        """Handle the result from the confirmation panel.
-
-        Args:
-            result: The action selected by the user
-
-        Returns:
-            Tuple of (action, guidance_text):
-                - action: "accept", "advise", "accept_all_edits", or "cancel"
-                - guidance_text: User's advice if action is "advise", None otherwise
-        """
-        # Handle advise input separately
-        if result == "advise":
-            from prompt_toolkit import PromptSession
-            from prompt_toolkit.formatted_text import HTML
-
-            guidance_session = PromptSession()
-            guidance = guidance_session.prompt(HTML("<b>Enter your advice: </b>")).strip()
-            if not guidance:
-                # Empty advise treated as cancel
-                return ("cancel", None)
-            return ("advise", guidance)
-
-        return (result, None)
-
-    def run(self) -> Tuple[str, Optional[str]]:
-        """Display the confirmation panel and wait for user input.
-
-        Returns:
-            Tuple of (action, guidance_text):
-                - action: "accept", "advise", "accept_all_edits", or "cancel"
-                - guidance_text: User's advice if action is "advise", None otherwise
-        """
-        # Create and run the application
-        bindings = self._create_key_bindings()
-        layout = self._create_layout()
-
-        application = Application(
-            layout=layout,
-            key_bindings=bindings,
-            full_screen=False,
-            mouse_support=False,
-        )
-
-        # Use run_async with asyncio to properly await coroutines
-        result = asyncio.run(application.run_async())
-        return self._handle_result(result)

package/src/utils/__init__.py

@@ -1 +0,0 @@
-"""Utility modules for bone-agent."""

package/src/utils/citation_parser.py

@@ -1,199 +0,0 @@
-"""Citation parser for sub-agent results.
-
-Parses bracketed citation patterns from sub-agent output and injects
-the actual file contents. This module is the single source of truth
-for the citation format contract between sub-agent and main agent.
-"""
-
-import re
-from dataclasses import dataclass
-from pathlib import Path
-from typing import List, Optional
-
-
-@dataclass
-class Citation:
-    """A parsed file citation from sub-agent output."""
-    rel_path: str
-    start_line: int
-    end_line: Optional[int] = None  # None means full file
-
-
-# Regex to find explicit citation patterns (bracketed notation only for safety)
-CITATION_PATTERN = re.compile(
-    r"(?:-\s+\[(.*?)\]\s+\((?:lines\s+)?(\d+)-(\d+)(?:\s*lines)?|full)\)|"
-    r"(?:lines\s+(\d+)-(\d+)\s+in\s+\[(.*?)\])|"
-    r"(?:\[(.*?)\]:(\d+)-(\d+))|"
-    r"(?:\[(.*?)\]:(\d+))|"
-    r"(?:\[([^\]]*?/[^\]]*?)\](?![:(]))"
-)
-
-
-def parse_citations(text: str) -> List[Citation]:
-    """Parse bracketed citation patterns from sub-agent output.
-
-    Supports these formats:
-        - [path/to/file] (lines N-M)    or (full)
-        - lines N-M in [path/to/file]
-        - [path/to/file]:N-M
-        - [path/to/file]:N
-        - [path/to/file]                 (full file)
-
-    Args:
-        text: Sub-agent result text to parse
-
-    Returns:
-        List of Citation instances found in the text
-    """
-    citations = []
-
-    for line in text.split('\n'):
-        match = CITATION_PATTERN.search(line)
-        if not match:
-            continue
-
-        if match.group(1):
-            # Pattern 1: - [file] (N-M) or (full)
-            rel_path = match.group(1).strip()
-            if match.group(2) and match.group(3):
-                start_line = int(match.group(2))
-                end_line = int(match.group(3))
-            else:
-                start_line = 1
-                end_line = None
-        elif match.group(4) and match.group(5) and match.group(6):
-            # Pattern 2: lines N-M in [file]
-            start_line = int(match.group(4))
-            end_line = int(match.group(5))
-            rel_path = match.group(6).strip()
-        elif match.group(7) and match.group(8) and match.group(9):
-            # Pattern 3: [file]:N-M
-            rel_path = match.group(7).strip()
-            start_line = int(match.group(8))
-            end_line = int(match.group(9))
-        elif match.group(10) and match.group(11):
-            # Pattern 4: [file]:N (single line)
-            rel_path = match.group(10).strip()
-            start_line = int(match.group(11))
-            end_line = start_line
-        elif match.group(12):
-            # Pattern 5: [file] (full file)
-            rel_path = match.group(12).strip()
-            start_line = 1
-            end_line = None
-        else:
-            continue
-
-        citations.append(Citation(
-            rel_path=rel_path,
-            start_line=start_line,
-            end_line=end_line,
-        ))
-
-    return citations
-
-
-def _format_header(citation: Citation, lines_read: Optional[int], actual_start_line: Optional[int]) -> str:
-    """Format a citation header string for injected content.
-
-    Args:
-        citation: The Citation being formatted
-        lines_read: Actual number of lines read (from metadata)
-        actual_start_line: Actual start line (from metadata)
-
-    Returns:
-        Formatted header string like "lines 45-78 (34 lines)"
-    """
-    if lines_read is not None:
-        actual_start = actual_start_line or citation.start_line
-        if actual_start > 1:
-            end = actual_start + lines_read - 1
-        else:
-            end = lines_read
-        line_label = "line" if lines_read == 1 else "lines"
-        return f"lines {actual_start}-{end} ({lines_read} {line_label})"
-    return "full"
-
-
-def inject_file_contents(
-    raw_result: str,
-    repo_root: Path,
-    gitignore_spec=None,
-    console=None,
-) -> str:
-    """Parse sub-agent result and inject actual file contents.
-
-    Extracts citations from the sub-agent output, reads the referenced
-    files, and appends the content in a structured format that the main
-    agent can use directly.
-
-    Args:
-        raw_result: Sub-agent result text containing citations
-        repo_root: Repository root directory
-        gitignore_spec: PathSpec for .gitignore filtering
-        console: Rich console for output (unused, kept for API compat)
-
-    Returns:
-        Combined string with original result + injected file contents,
-        or just the original result if no citations were found
-    """
-    from tools.file_reader import read_file as read_file_with_bypass
-    from utils.result_parsers import extract_multiple_metadata
-
-    citations = parse_citations(raw_result)
-    if not citations:
-        return raw_result
-
-    injected_files_content = []
-
-    for citation in citations:
-        max_lines = None
-        if citation.end_line is not None:
-            max_lines = citation.end_line - citation.start_line + 1
-
-        try:
-            tool_result = read_file_with_bypass(
-                citation.rel_path,
-                repo_root,
-                max_lines=max_lines,
-                start_line=citation.start_line,
-                gitignore_spec=gitignore_spec,
-            )
-
-            # Check for exit code
-            first_line = tool_result.split('\n')[0] if tool_result else ""
-            if first_line.startswith("exit_code="):
-                exit_code = first_line.split("=")[1].split()[0]
-                if exit_code != "0":
-                    injected_files_content.append(
-                        f"### {citation.rel_path} (Blocked or unavailable)"
-                    )
-                    injected_files_content.append(tool_result.strip())
-                    injected_files_content.append("")
-                    continue
-
-            # Strip metadata line and extract content
-            content_lines = tool_result.splitlines()[1:] if isinstance(tool_result, str) else []
-            content = "\n".join(content_lines).rstrip()
-
-            # Parse actual lines_read and start_line from metadata
-            metadata = extract_multiple_metadata(tool_result, 'lines_read', 'start_line')
-            lines_read = metadata.get('lines_read')
-            actual_start = metadata.get('start_line')
-
-            header_info = _format_header(citation, lines_read, actual_start)
-
-            injected_files_content.append(f"### {citation.rel_path} ({header_info})")
-            injected_files_content.append("```")
-            injected_files_content.append(content)
-            injected_files_content.append("```\n")
-
-        except Exception as e:
-            injected_files_content.append(
-                f"### {citation.rel_path} (Error reading file: {e})"
-            )
-
-    if not injected_files_content:
-        return raw_result
-
-    return raw_result + "\n\n## Injected File Contents\n\n" + "\n".join(injected_files_content)

package/src/utils/editor.py

@@ -1,207 +0,0 @@
-"""External editor integration for bone-agent."""
-import os
-import platform
-import shlex
-import subprocess
-import tempfile
-import shutil
-from pathlib import Path
-from typing import Tuple, Optional
-
-
-def get_editor() -> str:
-    """Get editor command with OS-specific defaults.
-
-    Priority:
-    1. Windows: notepad.exe
-    2. Linux: nvim, then EDITOR, then nano/vi/vim
-    3. Other Unix: EDITOR, then nano/vi/vim
-
-    Returns:
-        str: Editor command or path
-    """
-    system = platform.system()
-
-    if system == "Windows":
-        return "notepad.exe"
-
-    if system == "Linux" and shutil.which("nvim"):
-        return "nvim"
-
-    editor = os.environ.get("EDITOR")
-    if editor and editor.strip():
-        return editor.strip()
-
-    for cmd in ["nano", "vi", "vim"]:
-        if shutil.which(cmd):
-            return cmd
-
-    return "nano"
-
-
-def _create_temp_file() -> Tuple[Path, object]:
-    """Create temporary file for editing.
-
-    Returns:
-        tuple: (Path object, file handle)
-    """
-    # Create with .md extension for better syntax highlighting
-    temp_fd = tempfile.NamedTemporaryFile(
-        mode='w+',
-        suffix='.md',
-        prefix='bone_agent_edit_',
-        delete=False,
-        encoding='utf-8'
-    )
-
-    temp_fd.flush()
-
-    return Path(temp_fd.name), temp_fd
-
-
-def _strip_comment_lines(content: str) -> str:
-    """Remove comment lines (starting with #) from content.
-
-    Args:
-        content: Raw content from editor
-
-    Returns:
-        str: Content with comment lines removed
-    """
-    lines = []
-    for line in content.split('\n'):
-        stripped = line.strip()
-        # Keep empty lines and non-comment lines
-        if not stripped.startswith('#'):
-            lines.append(line)
-
-    return '\n'.join(lines).strip()
-
-
-def _build_editor_command(editor_cmd: str, temp_path: Path) -> Tuple[bool, str | list[str]]:
-    """Build a subprocess command for launching the configured editor."""
-    use_shell = platform.system() == "Windows"
-    if use_shell:
-        return use_shell, f'{editor_cmd} "{temp_path}"'
-
-    try:
-        command_parts = shlex.split(editor_cmd)
-    except ValueError as e:
-        raise ValueError(f"Invalid EDITOR command: {e}") from e
-
-    if not command_parts:
-        raise FileNotFoundError(editor_cmd)
-
-    return use_shell, [*command_parts, str(temp_path)]
-
-
-def _open_editor_with_temp_file(
-    console,
-    editor_cmd: str,
-    debug_mode: bool = False,
-    initial_content: str = "",
-    post_process=None,
-) -> Tuple[bool, Optional[str]]:
-    """Open the configured editor for a temporary file and return the saved content."""
-    temp_path = None
-
-    try:
-        temp_path, temp_fd = _create_temp_file()
-        if initial_content:
-            temp_fd.write(initial_content)
-            temp_fd.flush()
-        temp_fd.close()
-
-        if debug_mode:
-            console.print(f"[dim]Temp file: {temp_path}[/dim]")
-            console.print(f"[dim]Editor: {editor_cmd}[/dim]")
-
-        console.print("[#5F9EA0]Opening editor...[/#5F9EA0]")
-        console.print("[dim]Save and close the editor when done[/dim]")
-
-        use_shell, command = _build_editor_command(editor_cmd, temp_path)
-        result = subprocess.run(
-            command,
-            shell=use_shell,
-            check=False,
-        )
-
-        if result.returncode != 0 and debug_mode:
-            console.print(f"[yellow]Editor exited with code {result.returncode}[/yellow]")
-
-        content = temp_path.read_text(encoding="utf-8")
-        if post_process is not None:
-            content = post_process(content)
-
-        if debug_mode:
-            console.print(f"[dim]Read {len(content)} characters[/dim]")
-
-        return (True, content)
-
-    except FileNotFoundError:
-        console.print(f"[red]Editor '{editor_cmd}' not found[/red]", markup=False)
-        console.print("[dim]Set EDITOR as environment variable[/dim]")
-        if debug_mode:
-            console.print(f"[dim]Tried to run: {editor_cmd}[/dim]")
-        return (False, None)
-
-    except PermissionError as e:
-        console.print(f"[red]Permission denied: {e}[/red]", markup=False)
-        console.print("[dim]Check permissions on temporary directory[/dim]")
-        return (False, None)
-
-    except Exception as e:
-        console.print(f"[red]Failed to open editor: {e}[/red]", markup=False)
-        if debug_mode:
-            import traceback
-            console.print(f"[dim]{traceback.format_exc()}[/dim]")
-        return (False, None)
-
-    finally:
-        if temp_path and temp_path.exists():
-            try:
-                temp_path.unlink()
-                if debug_mode:
-                    console.print("[dim]Cleaned up temp file[/dim]")
-            except Exception as e:
-                console.print(f"[yellow]Warning: Failed to delete temp file: {e}[/yellow]")
-                if debug_mode:
-                    console.print(f"[dim]Temp file may remain at: {temp_path}[/dim]")
-
-
-def open_editor_for_input(console, debug_mode: bool = False) -> Tuple[bool, Optional[str]]:
-    """Open external editor and return user input.
-
-    Args:
-        console: Rich console for output
-        debug_mode: Whether to show debug information
-
-    Returns:
-        tuple: (success: bool, content: str or None)
-            - (True, content) if successful
-            - (False, None) if failed or cancelled
-    """
-    return _open_editor_with_temp_file(
-        console,
-        editor_cmd=get_editor(),
-        debug_mode=debug_mode,
-        post_process=_strip_comment_lines,
-    )
-
-
-def open_editor_for_content(
-    console,
-    initial_content: str = "",
-    debug_mode: bool = False,
-) -> Tuple[bool, Optional[str]]:
-    """Open external editor with initial content and return the saved file.
-
-    Unlike open_editor_for_input, this preserves markdown comment lines so it can
-    edit existing markdown files without dropping headings or notes.
-    """
-    return _open_editor_with_temp_file(
-        console,
-        editor_cmd=get_editor(),
-        debug_mode=debug_mode,
-        initial_content=initial_content or "",
-    )