bone-agent 1.4.0 → 2.0.1

package/src/core/sub_agent.py

@@ -1,376 +0,0 @@
-"""Sub-agent for delegated tasks.
-
-Uses existing AgenticOrchestrator with isolated message context
-and read-only tools to execute generic delegated tasks.
-"""
-
-from pathlib import Path
-
-from core.chat_manager import ChatManager
-from exceptions import LLMError
-from llm.prompts import build_sub_agent_prompt
-from utils.settings import sub_agent_settings
-
-
-class HardLimitExceeded(Exception):
-    """Raised when the sub-agent hits its hard token limit."""
-    pass
-
-
-class BilledLimitExceeded(Exception):
-    """Raised when the sub-agent hits its cumulative billed token limit."""
-    pass
-
-
-def _format_messages_dump(messages) -> str:
-    """Format sub-agent message history as a markdown dump.
-
-    Args:
-        messages: List of message dicts from the sub-agent ChatManager.
-
-    Returns:
-        Markdown string with the full conversation context.
-    """
-    lines = [
-        "## Sub-Agent Context Dump (Hard Limit Reached)",
-        "",
-        "The sub-agent exceeded its hard token limit. Below is the full, unabridged context of its investigation. No summary was produced.",
-        "",
-        "---",
-        "",
-    ]
-    for i, msg in enumerate(messages):
-        role = msg.get("role", "unknown")
-        content = msg.get("content", "")
-        tool_calls = msg.get("tool_calls")
-        tool_call_id = msg.get("tool_call_id")
-
-        if tool_call_id:
-            lines.append(f"### Message {i} — tool result ({tool_call_id})")
-        elif tool_calls:
-            lines.append(f"### Message {i} — assistant tool calls")
-            for tc in tool_calls:
-                fn = tc.get("function", {})
-                lines.append(f"- `{fn.get('name', '?')}` — `{fn.get('arguments', '')}`")
-        else:
-            lines.append(f"### Message {i} — {role}")
-
-        if content:
-            # Truncate large content to avoid blowing out the main agent's context
-            max_chars = 4000
-            if len(content) > max_chars:
-                content = content[:max_chars] + f"\n\n... (truncated, {len(content) - max_chars:,} chars omitted)"
-            lines.append(content)
-        lines.append("")
-    return "\n".join(lines)
-
-
-def _configure_compaction():
-    """Create a ChatManager with compaction settings from config.
-
-    Returns:
-        ChatManager: A new ChatManager instance with compaction configured
-    """
-    if sub_agent_settings.enable_compaction:
-        return ChatManager(compact_trigger_tokens=sub_agent_settings.compact_trigger_tokens)
-    else:
-        return ChatManager(compact_trigger_tokens=None)
-
-
-def _inject_system_prompt(chat_manager, sub_agent_type: str = "research"):
-    """Build sub-agent prompt and inject it.
-
-    Token usage is reported live by the wrapper in run_sub_agent(),
-    so the system prompt is kept clean.
-
-    Args:
-        chat_manager: ChatManager instance to configure
-        sub_agent_type: Type of sub-agent ('research' or 'review').
-    """
-    base_prompt = build_sub_agent_prompt(
-        sub_agent_type=sub_agent_type,
-        soft_limit_tokens=sub_agent_settings.soft_limit_tokens,
-        hard_limit_tokens=sub_agent_settings.hard_limit_tokens,
-    )
-    chat_manager.messages = [{"role": "system", "content": base_prompt}]
-
-
-def _load_codebase_map(chat_manager):
-    """Load agents.md codebase map into sub-agent context if available.
-
-    Args:
-        chat_manager: ChatManager instance to add context to
-    """
-    agents_path = Path.cwd() / "agents.md"
-    if agents_path.exists():
-        map_content = agents_path.read_text(encoding="utf-8").strip()
-        user_msg = (
-            "Here is the codebase map for this project. "
-            "This provides an overview of the repository structure and file purposes. "
-            "Use this as a reference when exploring the codebase.\n\n"
-            f"## Codebase Map (auto-generated from agents.md)\n\n{map_content}"
-        )
-        chat_manager.messages.append({"role": "user", "content": user_msg})
-
-
-def _configure_isolation(chat_manager):
-    """Apply isolation settings for sub-agent context.
-
-    Disables conversation logging.
-
-    Args:
-        chat_manager: ChatManager instance to configure
-    """
-    chat_manager.markdown_logger = None
-
-
-def _create_chat_manager(sub_agent_type: str = "research"):
-    """Create a fresh ChatManager instance for sub-agent use.
-
-    Orchestrates compaction, prompt injection, codebase map loading,
-    and isolation configuration.
-
-    Args:
-        sub_agent_type: Type of sub-agent ('research' or 'review').
-
-    Returns:
-        ChatManager: A new ChatManager instance with pre-configured system prompt
-    """
-    chat_manager = _configure_compaction()
-    chat_manager._compaction_disabled = True
-    _inject_system_prompt(chat_manager, sub_agent_type=sub_agent_type)
-    _load_codebase_map(chat_manager)
-    _configure_isolation(chat_manager)
-    return chat_manager
-
-
-def run_sub_agent(
-    task_query: str,
-    repo_root: Path,
-    rg_exe_path: str,
-    console=None,
-    panel_updater=None,
-    sub_agent_type: str = "research",
-    initial_context: str = None,
-) -> dict:
-    """Run sub-agent using existing AgenticOrchestrator for delegated tasks.
-
-    Args:
-        task_query: Generic task query to execute (e.g., "Read file config.json")
-        repo_root: Repository root path
-        rg_exe_path: Path to rg executable
-        console: Optional Rich console for output
-        panel_updater: Optional SubAgentPanel for live panel updates
-        sub_agent_type: Type of sub-agent ('research' or 'review').
-        initial_context: Optional string injected as context before the task query
-            (e.g., a git diff for review mode).
-
-    Returns:
-        Dict with:
-            - 'result': Formatted markdown string (goes into chat history)
-            - 'usage': Usage data for billing
-            - 'error': Error message if failed (None if success)
-    """
-    # Validate panel_updater type if provided
-    if panel_updater is not None and not hasattr(panel_updater, 'append'):
-        panel_updater = None
-
-    # If no panel_updater provided, create a simple no-op one
-    if panel_updater is None:
-        from tools.sub_agent import SimplePanelUpdater
-        panel_updater = SimplePanelUpdater(console)
-
-    # Create fresh ChatManager for sub-agent
-    temp_chat_manager = _create_chat_manager(sub_agent_type=sub_agent_type)
-
-    # Inject initial context as a user/assistant exchange if provided
-    if initial_context:
-        temp_chat_manager.messages.append(
-            {"role": "user", "content": initial_context}
-        )
-
-    # Import here to avoid circular import with core.agentic
-    from core.agentic import AgenticOrchestrator
-
-    # Create orchestrator (reuses existing implementation)
-    orchestrator = AgenticOrchestrator(
-        chat_manager=temp_chat_manager,
-        repo_root=repo_root,
-        rg_exe_path=rg_exe_path,
-        console=console,
-        debug_mode=False,
-        suppress_result_display=True,
-        is_sub_agent=True,
-        panel_updater=panel_updater,
-        force_parallel_execution=True  # Enable parallel execution for read-only tools
-    )
-
-    # Wrap orchestrator._get_llm_response to check hard token limit and
-    # wrap client.chat_completion once (outside the loop) to inject live
-    # token feedback as a system message — avoids per-call monkey-patching
-    # and eliminates any re-entrancy risk.
-    original_get_llm_response = orchestrator._get_llm_response
-    original_chat_completion = temp_chat_manager.client.chat_completion
-
-    _soft_limit_warned = False
-    _billed_warning_sent = False
-
-    def _chat_completion_with_token_hint(messages, **kwargs):
-        """Prepend a system-level token budget hint and one-time warnings to every LLM call."""
-        nonlocal _soft_limit_warned, _billed_warning_sent
-        tt = temp_chat_manager.token_tracker
-        hint = f"[Token budget: {tt.current_context_tokens:,} curr / {tt.conv_total_tokens:,} total billed]"
-        warnings = []
-
-        if not _soft_limit_warned and tt.current_context_tokens >= sub_agent_settings.soft_limit_tokens:
-            _soft_limit_warned = True
-            warnings.append(
-                f"WARNING: You have exceeded the current-context soft token limit "
-                f"({tt.current_context_tokens:,} / {sub_agent_settings.soft_limit_tokens:,}). "
-                "STOP exploring and return your findings immediately. Do NOT call any more tools."
-            )
-
-        if not _billed_warning_sent and tt.conv_total_tokens >= sub_agent_settings.billed_warning_tokens:
-            _billed_warning_sent = True
-            warnings.append(
-                f"WARNING: You have exceeded the cumulative billed token warning limit "
-                f"({tt.conv_total_tokens:,} / {sub_agent_settings.billed_warning_tokens:,}). "
-                "This sub-agent may be running away. STOP exploring and return your findings immediately. "
-                "Do NOT call any more tools."
-            )
-
-        if warnings:
-            hint = "\n".join([*warnings, hint])
-
-        token_msg = {"role": "system", "content": hint}
-        return original_chat_completion([token_msg, *messages], **kwargs)
-
-    def _get_llm_response_with_hard_limit(allowed_tools=None, allow_active_plugins=False):
-        """Wrapper to check context and billed token limits and update panel state."""
-        tt = temp_chat_manager.token_tracker
-
-        # Check hard token limit before making LLM call
-        # Use current_context_tokens (prompt size) not total_tokens (cumulative billing)
-        # to catch prompt-length-over-limit errors before they hit the API.
-        if tt.current_context_tokens >= sub_agent_settings.hard_limit_tokens:
-            raise HardLimitExceeded(
-                f"Sub-agent hard token limit exceeded: "
-                f"{tt.current_context_tokens:,} / {sub_agent_settings.hard_limit_tokens:,} tokens."
-            )
-
-        # Check cumulative billed tokens to stop runaway sub-agents even when
-        # current context remains below the prompt-size hard limit.
-        #
-        # Note: the billed warning is injected by _chat_completion_with_token_hint
-        # on the next chat_completion call. This hard stop runs before each LLM
-        # response, so once we hit the billed hard limit the warning may never be
-        # delivered if no further chat_completion call is made.
-        if tt.conv_total_tokens >= sub_agent_settings.billed_hard_limit_tokens:
-            raise BilledLimitExceeded(
-                f"Sub-agent billed token limit exceeded: "
-                f"{tt.conv_total_tokens:,} / {sub_agent_settings.billed_hard_limit_tokens:,} tokens."
-            )
-
-        # Update panel with live token counts
-        # Order: conversation length (current context) first, total tokens billed second
-        conv_length = tt.current_context_tokens
-        total_billed = tt.conv_total_tokens
-        if hasattr(panel_updater, 'token_info'):
-            panel_updater.token_info = f"{conv_length:,} curr | {total_billed:,} total"
-            panel_updater.append("")  # Refresh panel title
-
-        return original_get_llm_response(
-            allowed_tools=allowed_tools,
-            allow_active_plugins=allow_active_plugins,
-        )
-
-    # Apply both patches once, before the orchestrator loop starts
-    orchestrator._get_llm_response = _get_llm_response_with_hard_limit
-    temp_chat_manager.client.chat_completion = _chat_completion_with_token_hint
-
-    hard_limit_exceeded = False
-    billed_limit_exceeded = False
-
-    try:
-        # Run sub-agent task
-        orchestrator.run(
-            task_query,
-            thinking_indicator=None,
-            allowed_tools=sub_agent_settings.allowed_tools,
-            allow_active_plugins=sub_agent_settings.allow_active_plugins,
-        )
-    except HardLimitExceeded:
-        hard_limit_exceeded = True
-    except BilledLimitExceeded:
-        billed_limit_exceeded = True
-    except LLMError as e:
-        return {
-            "result": "",
-            "usage": {
-                "prompt_tokens": 0,
-                "completion_tokens": 0,
-                "total_tokens": 0
-            },
-            "model": temp_chat_manager.client.model,
-            "error": str(e)
-        }
-    except Exception as e:
-        import traceback
-        error_details = f"{e}\n\nTraceback:\n{traceback.format_exc()}"
-        return {
-            "result": "",
-            "usage": {
-                "prompt_tokens": 0,
-                "completion_tokens": 0,
-                "total_tokens": 0
-            },
-            "model": "",
-            "error": error_details
-        }
-    finally:
-        # Restore originals
-        temp_chat_manager.client.chat_completion = original_chat_completion
-
-    # Get final token usage (no need for delta calculation on fresh instance)
-    delta_prompt = temp_chat_manager.token_tracker.total_prompt_tokens
-    delta_completion = temp_chat_manager.token_tracker.total_completion_tokens
-    delta_total = temp_chat_manager.token_tracker.total_tokens
-    tt = temp_chat_manager.token_tracker
-    delta_cost = tt.total_actual_cost + tt.total_estimated_cost
-
-    if hard_limit_exceeded and sub_agent_settings.dump_context_on_hard_limit:
-        result = _format_messages_dump(temp_chat_manager.messages)
-    else:
-        # Extract final response (last assistant message with content)
-        final_content = ""
-        for msg in reversed(temp_chat_manager.messages):
-            if msg.get("role") == "assistant" and msg.get("content"):
-                final_content = msg["content"].strip()
-                break
-
-        if billed_limit_exceeded:
-            prefix = (
-                "WARNING: Sub-agent billed token limit reached. "
-                "Returning current findings early to prevent runaway execution."
-            )
-            result = f"{prefix}\n\n{final_content}" if final_content else prefix
-        else:
-            result = final_content
-
-    usage = {
-        "prompt_tokens": delta_prompt,
-        "completion_tokens": delta_completion,
-        "total_tokens": delta_total,
-        "context_tokens": tt.current_context_tokens,
-    }
-    if delta_cost > 0:
-        usage["cost"] = delta_cost
-
-    return {
-        "result": result,
-        "usage": usage,
-        "model": temp_chat_manager.client.model,
-        "error": None,
-        "hard_limit_exceeded": hard_limit_exceeded,
-        "billed_limit_exceeded": billed_limit_exceeded,
-    }

package/src/core/tool_approval.py

@@ -1,220 +0,0 @@
-"""Tool approval workflows for edit_file and execute_command."""
-
-from rich.text import Text
-
-from tools import confirm_tool
-
-
-def handle_edit_approval(preview, file_path, args_dict, console, thinking_indicator,
-                         approve_mode, cycle_approve_mode, repo_root, gitignore_spec,
-                         vault_root_str):
-    """Handle edit_file approval workflow.
-
-    Args:
-        preview: Either a rich Text object or a plain string to display.
-        file_path: The file path being edited (for the confirm prompt).
-        args_dict: Tool arguments dict (path, search, replace, context_lines).
-        console: Rich console for display.
-        thinking_indicator: ThinkingIndicator instance (may be None).
-        approve_mode: Current approval mode string.
-        cycle_approve_mode: Callable to cycle approval mode.
-        repo_root: Repository root path string.
-        gitignore_spec: Gitignore spec object.
-        vault_root_str: Callable returning vault root path string.
-
-    Returns:
-        (result_str, should_exit) tuple where should_exit=True means cancel the agentic loop.
-    """
-    # Display preview
-    console.print(preview)
-    console.print()
-
-    # Stop thinking indicator while waiting for user input
-    if thinking_indicator:
-        thinking_indicator.stop()
-
-    action, guidance = confirm_tool(
-        f"edit_file: {file_path}",
-        console,
-        reason=args_dict.get('reason', 'Apply file edit with above changes'),
-        requires_approval=True,
-        approve_mode=approve_mode,
-        is_edit_tool=True,
-        cycle_approve_mode=cycle_approve_mode
-    )
-
-    if action == "accept":
-        from tools.edit import _execute_edit_file
-        final_result = _execute_edit_file(
-            path=args_dict.get('path'),
-            search=args_dict.get('search'),
-            replace=args_dict.get('replace'),
-            repo_root=repo_root,
-            console=console,
-            gitignore_spec=gitignore_spec,
-            context_lines=args_dict.get('context_lines', 3),
-            vault_root=vault_root_str()
-        )
-        # Strip exit_code line from final result before displaying
-        if final_result and isinstance(final_result, str):
-            result_lines = [line for line in final_result.split('\n') if not line.startswith('exit_code=')]
-            final_result = '\n'.join(result_lines).strip()
-        result_str, should_exit = final_result, False
-    elif action == "advise":
-        console.print(f"[dim]Edit not applied. User advice: {guidance}[/dim]")
-        result_str = f"exit_code=1\nEdit not applied. User advice: {guidance}"
-        should_exit = False
-    else:  # cancel
-        console.print("[dim]Operation canceled by user.[/dim]")
-        result_str = "exit_code=1\nOperation canceled by user. Do not retry this operation."
-        should_exit = True
-
-    # Restart thinking indicator after user input
-    if thinking_indicator:
-        thinking_indicator.start()
-
-    return result_str, should_exit
-
-
-def resolve_edit_preview(result):
-    """Extract a displayable preview from an edit_file tool result.
-
-    Handles both Rich Text objects (new format) and legacy string format.
-
-    Args:
-        result: Either a rich Text object or a string.
-
-    Returns:
-        (preview, is_valid) tuple.
-        - preview: Text object, plain string, or None if error.
-        - is_valid: False if the result is an error (non-zero exit_code).
-    """
-    if isinstance(result, Text):
-        return result, True
-    elif isinstance(result, str) and result.startswith("exit_code=0"):
-        lines = result.split('\n')
-        preview_lines = [line for line in lines if not line.startswith("exit_code=")]
-        preview = '\n'.join(preview_lines).strip()
-        return preview, True
-    else:
-        # Error occurred during preview - don't show to user
-        return None, False
-
-
-def handle_command_approval(command, arguments, tool, context, console,
-                            thinking_indicator, approve_mode, debug_mode,
-                            cron_job_id=None, cron_allowlist=None,
-                            cron_interactive=False):
-    """Handle execute_command approval workflow.
-
-    Checks for silent blocks, auto-approval, and prompts user if needed.
-    When a cron_job_id and cron_allowlist are provided, commands on the
-    job's allow list are auto-approved; unlisted commands are blocked
-    (in scheduled mode) or prompted interactively (in test-run mode).
-
-    Args:
-        command: The shell command string.
-        arguments: Tool arguments dict (includes 'reason').
-        tool: The tool object to execute on approval.
-        context: Tool execution context dict.
-        console: Rich console for display.
-        thinking_indicator: ThinkingIndicator instance (may be None).
-        approve_mode: Current approval mode string.
-        debug_mode: Whether debug mode is active (for silent block logging).
-        cron_job_id: Optional cron job ID for allow list checking.
-        cron_allowlist: Optional CronAllowlist instance for cron command gating.
-        cron_interactive: If True, cron job is in interactive test-run mode.
-
-    Returns:
-        (result, should_exit, command_executed) tuple.
-        - result: Tool result string.
-        - should_exit: True if the user canceled (break the agentic loop).
-        - command_executed: True if the command was actually executed (display output).
-    """
-    from utils.validation import is_auto_approved_command, check_for_silent_blocked_command
-
-    # Check if command should be silently blocked (redirect to native tool)
-    is_blocked, reprompt_msg = check_for_silent_blocked_command(command)
-    if is_blocked:
-        if debug_mode:
-            console.print(f"[dim]Silently blocked command: {command.split()[0]}[/dim]")
-        result = f"exit_code=1\n{reprompt_msg}"
-        return result, False, False
-
-    # Check if command should be auto-approved (global safe commands)
-    auto_approve = is_auto_approved_command(command)
-
-    # Check cron allow list
-    cron_auto_approved = False
-    if cron_job_id and cron_allowlist:
-        if cron_allowlist.is_allowed(cron_job_id, command):
-            cron_auto_approved = True
-        elif not auto_approve:
-            # Command not on allow list and not globally safe
-            # Determine if we're in interactive test-run or scheduled mode
-            if cron_interactive:
-                # Interactive test run (/cron run) — prompt the user
-                pass  # Fall through to normal interactive approval below
-            else:
-                # Scheduled run — block the command, let agent adapt
-                allowed_cmds = cron_allowlist.get_commands(cron_job_id)
-                allowed_preview = ", ".join(f"'{c}'" for c in allowed_cmds[:5])
-                if len(allowed_cmds) > 5:
-                    allowed_preview += f", ... ({len(allowed_cmds)} total)"
-                if not allowed_preview:
-                    allowed_preview = "(none - run '/cron run <id>' to build the allow list)"
-                result = (
-                    f"exit_code=1\n"
-                    f"Command not in cron allow list for job '{cron_job_id}'.\n"
-                    f"Command: {command}\n"
-                    f"Allowed: {allowed_preview}\n"
-                    f"Do not retry this command. Use only approved commands or "
-                    f"ask the user to run '/cron run {cron_job_id}' to add it."
-                )
-                return result, False, False
-
-    if cron_auto_approved or auto_approve:
-        # Auto-approved command - execute without prompting
-        result = tool.execute(arguments, context)
-        command_executed = True
-
-        # In cron test-run mode, auto-save newly approved commands to allow list
-        # Skip globally-safe commands — they're auto-approved regardless of the allow list
-        if cron_job_id and cron_allowlist and cron_interactive and not auto_approve:
-            cron_allowlist.add_command(cron_job_id, command)
-
-        return result, False, command_executed
-
-    # Interactive approval (test-run mode or normal session)
-    # Stop thinking indicator while waiting for user input
-    if thinking_indicator:
-        thinking_indicator.stop()
-
-    action, guidance = confirm_tool(
-        f"execute_command: {command[:80]}{'...' if len(command) > 80 else ''}",
-        console,
-        reason=arguments.get('reason', 'Execute shell command'),
-        requires_approval=True,
-        approve_mode=approve_mode
-    )
-
-    if action == "accept":
-        result = tool.execute(arguments, context)
-        command_executed = True
-        # Auto-save approved command to cron allow list during test run
-        if cron_job_id and cron_allowlist:
-            cron_allowlist.add_command(cron_job_id, command)
-    elif action == "advise":
-        result = f"Command not executed. User advice: {guidance}"
-        command_executed = False
-    elif action == "cancel":
-        result = "Command canceled by user. Do not retry this operation."
-        if thinking_indicator:
-            thinking_indicator.start()
-        return result, True, False
-
-    # Restart thinking indicator after user input
-    if thinking_indicator:
-        thinking_indicator.start()
-
-    return result, False, command_executed