bone-agent 1.3.0

package/src/ui/tool_confirmation.py

@@ -0,0 +1,215 @@
+"""Interactive tool confirmation panel with arrow key navigation."""
+
+import asyncio
+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 _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("")
+            lines.append(f"<b>Tool:</b> {self.tool_command}")
+            lines.append(f'<style fg="gray">  Selected: {str(selected_text)}</style>')
+            lines.append("")
+        else:
+            # Tool information
+            lines.append(f"<b>Tool:</b> {self.tool_command}")
+            if self.reason:
+                lines.append(f"<b>Reason:</b> {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

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

package/src/utils/citation_parser.py

@@ -0,0 +1,199 @@
+"""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

@@ -0,0 +1,158 @@
+"""External editor integration for bone-agent."""
+import os
+import platform
+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. EDITOR environment variable
+    2. OS defaults: notepad.exe (Windows) | nano/vi/vim (Unix)
+
+    Returns:
+        str: Editor command or path
+    """
+    # 1. Check environment variable
+    editor = os.environ.get("EDITOR")
+    if editor and editor.strip():
+        return editor.strip()
+
+    # 2. OS-specific defaults
+    if platform.system() == "Windows":
+        return "notepad.exe"
+    else:
+        # Try to find common editors
+        for cmd in ["nvim", "nano", "vi", "vim"]:
+            if shutil.which(cmd):
+                return cmd
+        # Fallback to nano even if not found (will error later)
+        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 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
+    """
+    editor_cmd = get_editor()
+    temp_path = None
+
+    try:
+        # Create temporary file
+        temp_path, temp_fd = _create_temp_file()
+        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]")
+
+        # Launch editor and wait for it to close
+        # Use shell=True on Windows for notepad, False for better security on Unix
+        use_shell = platform.system() == "Windows"
+
+        result = subprocess.run(
+            [editor_cmd, str(temp_path)],
+            shell=use_shell,
+            check=False  # Don't raise on non-zero exit
+        )
+
+        if result.returncode != 0 and debug_mode:
+            console.print(f"[yellow]Editor exited with code {result.returncode}[/yellow]")
+
+        # Read content from temp file
+        content = temp_path.read_text(encoding='utf-8')
+
+        # Strip comment lines
+        content = _strip_comment_lines(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:
+        # Cleanup temp file
+        if temp_path and temp_path.exists():
+            try:
+                temp_path.unlink()
+                if debug_mode:
+                    console.print(f"[dim]Cleaned up temp file[/dim]")
+            except Exception as e:
+                # Log but don't crash on cleanup failure
+                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]")