henchman-ai 0.1.11__py3-none-any.whl → 0.1.12__py3-none-any.whl

henchman/cli/app.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import asyncio
 import os
 from typing import TYPE_CHECKING
 
@@ -58,15 +59,18 @@ def _get_provider() -> ModelProvider:
     )
 
 
-def _run_interactive(output_format: str, plan_mode: bool = False) -> None:
+def _run_interactive(output_format: str, plan_mode: bool = False, yes: bool = False) -> None:
     """Run interactive REPL mode.
 
     Args:
-        output_format: Output format (text, json, stream-json).
+        output_format: Output format (text, json, stream-json, json-complete).
         plan_mode: Whether to start in plan mode.
+        yes: Auto-approve all tool executions.
     """
+    from pathlib import Path
     from henchman.cli.repl import Repl, ReplConfig
     from henchman.config import ContextLoader, load_settings
+    from henchman.core.session import SessionManager
     from henchman.rag import initialize_rag
 
     provider = _get_provider()
@@ -76,7 +80,7 @@ def _run_interactive(output_format: str, plan_mode: bool = False) -> None:
     context_loader = ContextLoader()
     system_prompt = context_loader.load()
 
-    config = ReplConfig(system_prompt=system_prompt)
+    config = ReplConfig(system_prompt=system_prompt, auto_approve_tools=yes)
     repl = Repl(
         provider=provider,
         console=console,
@@ -84,8 +88,16 @@ def _run_interactive(output_format: str, plan_mode: bool = False) -> None:
         settings=settings
     )
 
+    # Initialize session management
+    session_manager = SessionManager()
+    project_hash = session_manager.compute_project_hash(Path.cwd())
+    session = session_manager.create_session(project_hash)
+    
+    repl.session_manager = session_manager
+    repl.session = session
+
     # Initialize RAG system
-    rag_system = initialize_rag(settings.rag, console=console)
+    rag_system = initialize_rag(settings.rag, console=console, index=False)
     if rag_system:
         repl.tool_registry.register(rag_system.search_tool)
         repl.rag_system = rag_system
@@ -108,18 +120,21 @@ def _run_interactive(output_format: str, plan_mode: bool = False) -> None:
         anyio.run(repl.run)
 
 
-def _run_headless(prompt: str, output_format: str, plan_mode: bool = False) -> None:
+def _run_headless(prompt: str, output_format: str, plan_mode: bool = False, yes: bool = False) -> None:
     """Run headless mode with a single prompt.
 
     Args:
         prompt: The prompt to process.
-        output_format: Output format (text, json, stream-json).
+        output_format: Output format (text, json, stream-json, json-complete).
         plan_mode: Whether to run in plan mode.
+        yes: Auto-approve all tool executions.
     """
+    from pathlib import Path
     from henchman.cli.json_output import JsonOutputRenderer
     from henchman.cli.repl import Repl, ReplConfig
     from henchman.config import ContextLoader, load_settings
     from henchman.core.events import EventType
+    from henchman.core.session import SessionManager
     from henchman.rag import initialize_rag
 
     provider = _get_provider()
@@ -134,11 +149,19 @@ def _run_headless(prompt: str, output_format: str, plan_mode: bool = False) -> N
         from henchman.cli.commands.plan import PLAN_MODE_PROMPT
         system_prompt += PLAN_MODE_PROMPT
 
-    config = ReplConfig(system_prompt=system_prompt)
+    config = ReplConfig(system_prompt=system_prompt, auto_approve_tools=yes)
     repl = Repl(provider=provider, console=console, config=config, settings=settings)
 
+    # Initialize session management
+    session_manager = SessionManager()
+    project_hash = session_manager.compute_project_hash(Path.cwd())
+    session = session_manager.create_session(project_hash)
+    
+    repl.session_manager = session_manager
+    repl.session = session
+
     # Initialize RAG system
-    rag_system = initialize_rag(settings.rag)  # No console output in headless
+    rag_system = initialize_rag(settings.rag, index=False)  # No console output in headless
     if rag_system:
         repl.tool_registry.register(rag_system.search_tool)
         repl.rag_system = rag_system
@@ -150,23 +173,100 @@ def _run_headless(prompt: str, output_format: str, plan_mode: bool = False) -> N
 
     async def run_single_prompt_text() -> None:  # pragma: no cover
         """Process a single prompt and exit with text output."""
-        async for event in repl.agent.run(prompt):
-            if event.type == EventType.CONTENT:
-                console.print(event.data, end="")
-            elif event.type == EventType.FINISHED:
-                console.print()
+        if repl.rag_system:
+            asyncio.create_task(repl.rag_system.index_async())
+        await repl.process_input(prompt)
 
     async def run_single_prompt_json() -> None:
         """Process a single prompt and exit with JSON output."""
+        from henchman.core.events import AgentEvent, EventType
+        from henchman.providers.base import ToolCall
+        from collections.abc import AsyncIterator
+
+        if repl.rag_system:
+            asyncio.create_task(repl.rag_system.index_async())
+
         json_renderer = JsonOutputRenderer(console)
-        async for event in repl.agent.run(prompt):
-            json_renderer.render(event)
+        
+        # We need to manually run the tool loop for JSON output
+        # to ensure all events are rendered as JSON
+        async def run_and_render(stream: AsyncIterator[AgentEvent]) -> None:
+            pending_tool_calls = []
+            async for event in stream:
+                json_renderer.render(event)
+                if event.type == EventType.TOOL_CALL_REQUEST:
+                    pending_tool_calls.append(event.data)
+            
+            if pending_tool_calls:
+                # Execute tool calls
+                for tool_call in pending_tool_calls:
+                    result = await repl.tool_registry.execute(tool_call.name, tool_call.arguments)
+                    repl.agent.submit_tool_result(tool_call.id, result.content)
+                    # Emit tool result event
+                    json_renderer.render(AgentEvent(type=EventType.TOOL_RESULT, data=result))
+                
+                # Continue
+                await run_and_render(repl.agent.continue_with_tool_results())
+
+        await run_and_render(repl.agent.run(prompt))
 
     async def run_single_prompt_stream_json() -> None:
         """Process a single prompt and exit with streaming JSON output."""
+        from henchman.core.events import AgentEvent, EventType
+        from henchman.providers.base import ToolCall
+        from collections.abc import AsyncIterator
+
+        if repl.rag_system:
+            asyncio.create_task(repl.rag_system.index_async())
+
         json_renderer = JsonOutputRenderer(console)
-        async for event in repl.agent.run(prompt):
-            json_renderer.render_stream_json(event)
+        
+        async def run_and_render_stream(stream: AsyncIterator[AgentEvent]) -> None:
+            pending_tool_calls = []
+            async for event in stream:
+                json_renderer.render_stream_json(event)
+                if event.type == EventType.TOOL_CALL_REQUEST:
+                    pending_tool_calls.append(event.data)
+            
+            if pending_tool_calls:
+                for tool_call in pending_tool_calls:
+                    result = await repl.tool_registry.execute(tool_call.name, tool_call.arguments)
+                    repl.agent.submit_tool_result(tool_call.id, result.content)
+                    json_renderer.render_stream_json(AgentEvent(type=EventType.TOOL_RESULT, data=result))
+                
+                await run_and_render_stream(repl.agent.continue_with_tool_results())
+
+        await run_and_render_stream(repl.agent.run(prompt))
+
+    async def run_single_prompt_json_complete() -> None:
+        """Process a single prompt and exit with complete JSON output."""
+        from henchman.core.events import AgentEvent, EventType
+        from henchman.providers.base import ToolCall
+        from collections.abc import AsyncIterator
+
+        if repl.rag_system:
+            asyncio.create_task(repl.rag_system.index_async())
+
+        json_renderer = JsonOutputRenderer(console)
+        all_events: list[AgentEvent] = []
+        
+        async def run_and_collect(stream: AsyncIterator[AgentEvent]) -> None:
+            pending_tool_calls = []
+            async for event in stream:
+                all_events.append(event)
+                if event.type == EventType.TOOL_CALL_REQUEST:
+                    pending_tool_calls.append(event.data)
+            
+            if pending_tool_calls:
+                for tool_call in pending_tool_calls:
+                    result = await repl.tool_registry.execute(tool_call.name, tool_call.arguments)
+                    repl.agent.submit_tool_result(tool_call.id, result.content)
+                    all_events.append(AgentEvent(type=EventType.TOOL_RESULT, data=result))
+                
+                await run_and_collect(repl.agent.continue_with_tool_results())
+
+        await run_and_collect(repl.agent.run(prompt))
+        json_renderer.render_final_json(all_events)
 
     if output_format == "text":
         anyio.run(run_single_prompt_text)
@@ -174,16 +274,18 @@ def _run_headless(prompt: str, output_format: str, plan_mode: bool = False) -> N
         anyio.run(run_single_prompt_json)
     elif output_format == "stream-json":
         anyio.run(run_single_prompt_stream_json)
+    elif output_format == "json-complete":
+        anyio.run(run_single_prompt_json_complete)
     else:  # pragma: no cover
         pass
 
 
 @click.command()
-@click.version_option(version=VERSION, prog_name="mlg")
+@click.version_option(version=VERSION, prog_name="henchman")
 @click.option("-p", "--prompt", help="Run with a single prompt and exit")
 @click.option(
     "--output-format",
-    type=click.Choice(["text", "json", "stream-json"]),
+    type=click.Choice(["text", "json", "stream-json", "json-complete"]),
     default="text",
     help="Output format for responses",
 )
@@ -193,15 +295,22 @@ def _run_headless(prompt: str, output_format: str, plan_mode: bool = False) -> N
     default=False,
     help="Start in plan mode (read-only)",
 )
-def cli(prompt: str | None, output_format: str, plan: bool) -> None:
+@click.option(
+    "-y",
+    "--yes",
+    is_flag=True,
+    default=False,
+    help="Auto-approve all tool executions (non-interactive mode)",
+)
+def cli(prompt: str | None, output_format: str, plan: bool, yes: bool) -> None:
     """Henchman-AI: A model-agnostic AI agent CLI.
 
     Start an interactive session or run with --prompt for headless mode.
     """
     if prompt:
-        _run_headless(prompt, output_format, plan)
+        _run_headless(prompt, output_format, plan, yes)
     else:
-        _run_interactive(output_format, plan)
+        _run_interactive(output_format, plan, yes)
 
 
 def main() -> None:  # pragma: no cover

henchman/cli/commands/builtins.py

@@ -6,6 +6,8 @@ This module provides the default slash commands like /help, /quit, /clear, /tool
 from __future__ import annotations
 
 from henchman.cli.commands import Command, CommandContext
+from henchman.cli.commands.chat import ChatCommand
+from henchman.cli.commands.mcp import McpCommand
 from henchman.cli.commands.plan import PlanCommand
 from henchman.cli.commands.rag import RagCommand
 from henchman.cli.commands.skill import SkillCommand
@@ -53,6 +55,8 @@ class HelpCommand(Command):
         ctx.console.print("  /plan     - Toggle Plan Mode (Read-Only)")
         ctx.console.print("  /rag      - Manage semantic search index")
         ctx.console.print("  /skill    - Manage and execute learned skills")
+        ctx.console.print("  /chat     - Manage chat sessions (save, list, resume)")
+        ctx.console.print("  /mcp      - Manage MCP server connections")
         ctx.console.print("  /quit     - Exit the CLI")
         ctx.console.print("  /clear    - Clear the screen")
         ctx.console.print("  /tools    - List available tools")
@@ -206,6 +210,8 @@ def get_builtin_commands() -> list[Command]:
         QuitCommand(),
         ClearCommand(),
         ToolsCommand(),
+        ChatCommand(),
+        McpCommand(),
         PlanCommand(),
         RagCommand(),
         SkillCommand(),

henchman/cli/commands/chat.py

@@ -67,9 +67,9 @@ class ChatCommand(Command):
     async def _show_help(self, ctx: CommandContext) -> None:
         """Show help for /chat command."""
         ctx.console.print("\n[bold blue]Chat Session Commands[/]\n")
-        ctx.console.print("  /chat save [tag]    - Save current session")
-        ctx.console.print("  /chat list          - List saved sessions")
-        ctx.console.print("  /chat resume <tag>  - Resume a saved session")
+        ctx.console.print("  /chat save [tag]       - Save current session")
+        ctx.console.print("  /chat list             - List saved sessions")
+        ctx.console.print("  /chat resume <tag|id>  - Resume a saved session")
         ctx.console.print("")
 
     async def _save(self, ctx: CommandContext) -> None:
@@ -124,46 +124,60 @@ class ChatCommand(Command):
             return
 
         if len(ctx.args) < 2:
-            ctx.console.print("[yellow]Usage: /chat resume <tag>[/]")
+            ctx.console.print("[yellow]Usage: /chat resume <tag|id>[/]")
             return
 
-        tag = ctx.args[1]
+        tag_or_id = ctx.args[1]
         project_hash = getattr(ctx, "project_hash", None)
 
-        session = manager.load_by_tag(tag, project_hash)
+        # Try loading by tag first
+        session = manager.load_by_tag(tag_or_id, project_hash)
+        
+        # If that fails, try loading by ID
         if session is None:
-            ctx.console.print(f"[red]Session not found: {tag}[/]")
+            try:
+                session = manager.load(tag_or_id)
+            except (ValueError, FileNotFoundError):
+                pass
+        
+        if session is None:
+            ctx.console.print(f"[red]Session not found: {tag_or_id}[/]")
             return
 
-        manager.set_current(session)
-
-        # Restore session messages to agent history
-        if ctx.agent is not None:
-            # Clear agent history (keeping system prompt)
-            ctx.agent.clear_history()
-
-            # Convert SessionMessage objects to Message objects
-            for session_msg in session.messages:
-                # Convert tool_calls from dicts to ToolCall objects if present
-                tool_calls = None
-                if session_msg.tool_calls:
-                    tool_calls = [
-                        ToolCall(
-                            id=tc.get("id", ""),
-                            name=tc.get("name", ""),
-                            arguments=tc.get("arguments", {}),
-                        )
-                        for tc in session_msg.tool_calls
-                    ]
-
-                msg = Message(
-                    role=session_msg.role,
-                    content=session_msg.content,
-                    tool_calls=tool_calls,
-                    tool_call_id=session_msg.tool_call_id,
-                )
-                ctx.agent.messages.append(msg)
+        # Use repl.set_session if available to handle all sync logic
+        if ctx.repl and hasattr(ctx.repl, "set_session"):
+            ctx.repl.set_session(session)
+        else:
+            # Fallback for when REPL isn't available (e.g. some tests)
+            manager.set_current(session)
+
+            # Restore session messages to agent history
+            if ctx.agent is not None:
+                # Clear agent history (keeping system prompt)
+                ctx.agent.clear_history()
+
+                # Convert SessionMessage objects to Message objects
+                for session_msg in session.messages:
+                    # Convert tool_calls from dicts to ToolCall objects if present
+                    tool_calls = None
+                    if session_msg.tool_calls:
+                        tool_calls = [
+                            ToolCall(
+                                id=tc.get("id", ""),
+                                name=tc.get("name", ""),
+                                arguments=tc.get("arguments", {}),
+                            )
+                            for tc in session_msg.tool_calls
+                        ]
+
+                    msg = Message(
+                        role=session_msg.role,
+                        content=session_msg.content,
+                        tool_calls=tool_calls,
+                        tool_call_id=session_msg.tool_call_id,
+                    )
+                    ctx.agent.messages.append(msg)
 
         ctx.console.print(
-            f"[green]✓[/] Resumed session '{tag}' ({len(session.messages)} messages)"
+            f"[green]✓[/] Resumed session '{tag_or_id}' ({len(session.messages)} messages)"
         )

henchman/cli/commands/rag.py

@@ -125,12 +125,17 @@ class RagCommand(Command):
             )
             return
 
+        if getattr(rag_system, "is_indexing", False):
+            ctx.console.print("[yellow]RAG indexing is already in progress in the background.[/]")
+            return
+
         ctx.console.print("[dim]Forcing full reindex...[/]")
         stats = rag_system.index(console=ctx.console, force=True)
-        ctx.console.print(
-            f"[green]Reindex complete: {stats.files_added} files, "
-            f"{stats.total_chunks} chunks[/]"
-        )
+        if stats:
+            ctx.console.print(
+                f"[green]Reindex complete: {stats.files_added} files, "
+                f"{stats.total_chunks} chunks[/]"
+            )
 
     async def _clear(self, ctx: CommandContext) -> None:
         """Clear the RAG index."""

henchman/cli/console.py

@@ -7,6 +7,7 @@ from __future__ import annotations
 
 from dataclasses import dataclass
 
+import anyio
 from rich.console import Console
 from rich.markdown import Markdown
 from rich.markup import escape
@@ -302,4 +303,7 @@ class OutputRenderer:
             True if confirmed.
         """
         from rich.prompt import Confirm
-        return Confirm.ask(message, console=self.console)
+        import anyio
+        return await anyio.to_thread.run_sync(
+            lambda: Confirm.ask(message, console=self.console)
+        )

henchman/cli/input.py

@@ -5,6 +5,7 @@ This module handles user input including @ file references and ! shell commands.
 
 from __future__ import annotations
 
+import asyncio
 import contextlib
 import re
 from pathlib import Path
@@ -168,3 +169,67 @@ class InputHandler:
             The prompt string.
         """
         return self._prompt
+
+
+class KeyMonitor:
+    """Monitors for specific keys while an async task is running.
+
+    This is used to detect Escape or Ctrl+C while the agent is generating output.
+    """
+
+    def __init__(self) -> None:
+        """Initialize the key monitor."""
+        from prompt_toolkit.input import create_input
+        self.input = create_input()
+        self._stop_event = asyncio.Event()
+        self._exit_event = asyncio.Event()
+        self._suspended = asyncio.Event()
+        self._suspended.set() # Not suspended initially
+        self._in_raw_mode = False
+
+    async def suspend(self) -> None:
+        """Suspend monitoring to allow other input reading."""
+        self._suspended.clear()
+        # Wait for the monitor loop to exit the raw mode block
+        while self._in_raw_mode:
+            await asyncio.sleep(0.01)
+
+    def resume(self) -> None:
+        """Resume monitoring."""
+        self._suspended.set()
+
+    async def monitor(self) -> None:
+        """Monitor input for keys. Run this in a background task."""
+        while not self._stop_event.is_set() and not self._exit_event.is_set():
+            if not self._suspended.is_set():
+                await asyncio.sleep(0.1)
+                continue
+
+            try:
+                with self.input.raw_mode():
+                    self._in_raw_mode = True
+                    with self.input.attach(lambda: None):
+                        while not self._stop_event.is_set() and not self._exit_event.is_set() and self._suspended.is_set():
+                            # Check for keys every 100ms
+                            keys = self.input.read_keys()
+                            for key in keys:
+                                if key.key == Keys.Escape:
+                                    self._stop_event.set()
+                                elif key.key == Keys.ControlC:
+                                    self._exit_event.set()
+                            await asyncio.sleep(0.1)
+            finally:
+                self._in_raw_mode = False
+                # If we were suspended, wait a bit before potentially re-entering raw mode
+                if not self._suspended.is_set():
+                    await asyncio.sleep(0.1)
+
+    @property
+    def stop_requested(self) -> bool:
+        """Check if Escape was pressed."""
+        return self._stop_event.is_set()
+
+    @property
+    def exit_requested(self) -> bool:
+        """Check if Ctrl+C was pressed."""
+        return self._exit_event.is_set()

henchman/cli/repl.py

@@ -5,6 +5,7 @@ This module provides the main interactive loop for the CLI.
 
 from __future__ import annotations
 
+import asyncio
 from collections.abc import AsyncIterator
 from dataclasses import dataclass
 from pathlib import Path
@@ -19,7 +20,8 @@ from henchman.cli.input import create_session, expand_at_references, is_slash_co
 from henchman.core.agent import Agent
 from henchman.core.events import AgentEvent, EventType
 from henchman.core.session import Session, SessionManager, SessionMessage
-from henchman.providers.base import ModelProvider, ToolCall
+from henchman.providers.base import Message, ModelProvider, ToolCall
+from henchman.tools.base import ConfirmationRequest, ToolKind
 from henchman.tools.registry import ToolRegistry
 
 if TYPE_CHECKING:
@@ -37,6 +39,7 @@ class ReplConfig:
         history_file: Path to history file.
         base_tool_iterations: Base limit for tool iterations per turn.
         max_tool_calls_per_turn: Maximum tool calls allowed per turn.
+        auto_approve_tools: Auto-approve all tool executions (non-interactive mode).
     """
 
     prompt: str = "❯ "
@@ -45,6 +48,7 @@ class ReplConfig:
     history_file: Path | None = None
     base_tool_iterations: int = 25
     max_tool_calls_per_turn: int = 100
+    auto_approve_tools: bool = False
 
 
 class Repl:
@@ -82,6 +86,7 @@ class Repl:
 
         # Initialize tool registry with built-in tools
         self.tool_registry = ToolRegistry()
+        self.tool_registry.set_confirmation_handler(self._handle_confirmation)
         self._register_builtin_tools()
 
         # Determine max_tokens from settings
@@ -128,6 +133,43 @@ class Repl:
 
         # RAG system (set externally by app.py)
         self.rag_system: object | None = None
+        self.current_monitor: object | None = None
+
+    def set_session(self, session: Session) -> None:
+        """Set the current session and sync with agent history.
+
+        Args:
+            session: The session to activate.
+        """
+        self.session = session
+        if self.session_manager:
+            self.session_manager.set_current(session)
+
+        # Restore session messages to agent history
+        # Clear agent history (keeping current system prompt)
+        self.agent.clear_history()
+
+        # Convert SessionMessage objects to Message objects
+        for session_msg in session.messages:
+            # Convert tool_calls from dicts to ToolCall objects if present
+            tool_calls = None
+            if session_msg.tool_calls:
+                tool_calls = [
+                    ToolCall(
+                        id=tc.get("id", ""),
+                        name=tc.get("name", ""),
+                        arguments=tc.get("arguments", {}),
+                    )
+                    for tc in session_msg.tool_calls
+                ]
+
+            msg = Message(
+                role=session_msg.role,
+                content=session_msg.content,
+                tool_calls=tool_calls,
+                tool_call_id=session_msg.tool_call_id,
+            )
+            self.agent.messages.append(msg)
 
     def _get_toolbar_status(self) -> list[tuple[str, str]]:
         """Get status bar content."""
@@ -150,6 +192,10 @@ class Repl:
         except Exception:
             pass
 
+        # RAG Status
+        if self.rag_system and getattr(self.rag_system, "is_indexing", False):
+            status.append(("bg:cyan fg:black", " RAG: Indexing... "))
+
         return status
 
     def _register_builtin_tools(self) -> None:
@@ -180,6 +226,40 @@ class Repl:
         for tool in tools:
             self.tool_registry.register(tool)
 
+    async def _handle_confirmation(self, request: ConfirmationRequest) -> bool:
+        """Handle a tool confirmation request from the registry.
+
+        Args:
+            request: The confirmation request data.
+
+        Returns:
+            True if approved, False otherwise.
+        """
+        # Auto-approve if configured
+        if self.config.auto_approve_tools:
+            return True
+        
+        # Formulate a clear message for the user
+        import json
+        
+        msg = f"Allow tool [bold cyan]{request.tool_name}[/] to "
+        
+        if request.tool_name == "shell":
+            command = request.params.get("command", "unknown command") if request.params else "unknown command"
+            msg += f"run command: [yellow]{command}[/]"
+        elif request.tool_name == "write_file":
+            path = request.params.get("path", "unknown path") if request.params else "unknown path"
+            msg += f"write to file: [yellow]{path}[/]"
+        elif request.tool_name == "edit_file":
+            path = request.params.get("path", "unknown path") if request.params else "unknown path"
+            msg += f"edit file: [yellow]{path}[/]"
+        else:
+            msg += f"execute: {request.description}"
+            if request.params:
+                msg += f"\nParams: [dim]{json.dumps(request.params)}[/]"
+            
+        return await self.renderer.confirm_tool_execution(msg)
+
     async def run(self) -> None:
         """Run the main REPL loop.
 
@@ -188,6 +268,10 @@ class Repl:
         self.running = True
         self._print_welcome()
 
+        # Start background indexing if RAG is available
+        if self.rag_system and hasattr(self.rag_system, "index_async"):
+            asyncio.create_task(self.rag_system.index_async())
+
         try:
             while self.running:
                 try:
@@ -196,9 +280,9 @@ class Repl:
                     if not should_continue:
                         break
                 except KeyboardInterrupt:
-                    # In PromptSession, Ctrl-C raises KeyboardInterrupt
-                    # We treat it as clearing the line or exiting if repeated
-                    continue
+                    # Ctrl-C instantly ends the session
+                    self.running = False
+                    break
                 except EOFError:
                     self.console.print()
                     break
@@ -306,6 +390,12 @@ class Repl:
             session=self.session,
             repl=self,
         )
+        # Add session_manager and project_hash for /chat command
+        if self.session_manager:
+            setattr(ctx, "session_manager", self.session_manager)
+            from pathlib import Path
+            setattr(ctx, "project_hash", self.session_manager.compute_project_hash(Path.cwd()))
+            
         await cmd.execute(ctx)
         return True
 
@@ -322,16 +412,48 @@ class Repl:
         # Collect assistant response - now also tracks tool calls for session
         assistant_content: list[str] = []
 
-        try:
-            await self._process_agent_stream(
+        from henchman.cli.input import KeyMonitor
+        monitor = KeyMonitor()
+        self.current_monitor = monitor
+        monitor_task = asyncio.create_task(monitor.monitor())
+
+        # Run the agent stream processing as a separate task so we can cancel it
+        agent_task = asyncio.create_task(
+            self._process_agent_stream(
                 self.agent.run(user_input),
                 assistant_content
             )
+        )
+
+        try:
+            while not agent_task.done():
+                if monitor.exit_requested:
+                    self.renderer.warning("\n[Exit requested by Ctrl+C]")
+                    self.running = False
+                    agent_task.cancel()
+                    break
+                if monitor.stop_requested:
+                    self.renderer.warning("\n[Interrupted by Esc]")
+                    agent_task.cancel()
+                    break
+                # Small sleep to keep the loop responsive
+                await asyncio.sleep(0.05)
+
+            if not agent_task.done():
+                try:
+                    await agent_task
+                except asyncio.CancelledError:
+                    pass
+            else:
+                # Task finished normally, await it to raise any exceptions
+                await agent_task
+
         except Exception as e:
             self.renderer.error(f"Error: {e}")
-
-        # Session recording is now handled within _process_agent_stream
-        # and _execute_tool_calls to properly capture tool calls and results
+        finally:
+            # Ensure monitor task is cleaned up
+            monitor._stop_event.set()
+            await monitor_task
 
     async def _process_agent_stream(
         self,
@@ -445,35 +567,38 @@ class Repl:
         # Increment iteration counter (one batch of tool calls = one iteration)
         self.agent.turn.increment_iteration()
 
-        # Execute all tool calls and submit results
-        for tool_call in tool_calls:
-            if not isinstance(tool_call, ToolCall):
-                continue
-
-            self.renderer.muted(f"\n[tool] {tool_call.name}({tool_call.arguments})")
-
-            # Execute the tool
-            result = await self.tool_registry.execute(tool_call.name, tool_call.arguments)
-
-            # Record tool call in turn state for loop detection
+        responded_ids = set()
+        
+        # Split tool calls into those that need confirmation and those that don't
+        # to allow parallel execution of "safe" tools.
+        to_parallel: list[ToolCall] = []
+        to_sequential: list[ToolCall] = []
+        
+        for tc in tool_calls:
+            tool = self.tool_registry.get(tc.name)
+            # Use same logic as ToolRegistry.execute for confirmation check
+            if tool and (tc.name in self.tool_registry._auto_approve_policies or 
+                         tool.needs_confirmation(tc.arguments) is None):
+                to_parallel.append(tc)
+            else:
+                to_sequential.append(tc)
+
+        async def execute_and_record(tc: ToolCall) -> None:
+            self.renderer.muted(f"\n[tool] {tc.name}({tc.arguments})")
+            result = await self.tool_registry.execute(tc.name, tc.arguments)
+            
+            # Record results (thread-safe for agent/session lists)
+            responded_ids.add(tc.id)
             self.agent.turn.record_tool_call(
-                tool_call_id=tool_call.id,
-                tool_name=tool_call.name,
-                arguments=tool_call.arguments,
+                tool_call_id=tc.id,
+                tool_name=tc.name,
+                arguments=tc.arguments,
                 result=result,
             )
-
-            # Submit result to agent
-            self.agent.submit_tool_result(tool_call.id, result.content)
-
-            # Record tool result to session
+            self.agent.submit_tool_result(tc.id, result.content)
             if self.session is not None:
                 self.session.messages.append(
-                    SessionMessage(
-                        role="tool",
-                        content=result.content,
-                        tool_call_id=tool_call.id,
-                    )
+                    SessionMessage(role="tool", content=result.content, tool_call_id=tc.id)
                 )
 
             # Show result
@@ -482,6 +607,38 @@ class Repl:
             else:
                 self.renderer.error(f"[error] {result.error}")
 
+        try:
+            # 1. Execute parallel group (tools not needing confirmation)
+            if to_parallel:
+                await asyncio.gather(*(execute_and_record(tc) for tc in to_parallel))
+                
+            # 2. Execute sequential group (tools needing confirmation)
+            if to_sequential:
+                # Suspend key monitor while we might be showing confirmation prompts
+                if hasattr(self, "current_monitor") and self.current_monitor:
+                    await self.current_monitor.suspend()
+                
+                try:
+                    for tc in to_sequential:
+                        await execute_and_record(tc)
+                finally:
+                    if hasattr(self, "current_monitor") and self.current_monitor:
+                        self.current_monitor.resume()
+        finally:
+            # Ensure all tool calls have a response, even if interrupted
+            for tool_call in tool_calls:
+                if tool_call.id not in responded_ids:
+                    cancel_msg = "Tool execution was interrupted or cancelled."
+                    self.agent.submit_tool_result(tool_call.id, cancel_msg)
+                    if self.session is not None:
+                        self.session.messages.append(
+                            SessionMessage(
+                                role="tool",
+                                content=cancel_msg,
+                                tool_call_id=tool_call.id,
+                            )
+                        )
+
         # Show turn status after tool execution
         self._show_turn_status()
 

henchman/core/turn.py

@@ -68,9 +68,15 @@ class TurnState:
         self.tool_count += 1
 
         # Track for duplicate detection
+        # Be more lenient with read-only operations
+        is_read_only = tool_name in ("read_file", "ls", "glob", "grep", "rag_search")
         call_sig = f"{tool_name}:{_hash_content(str(sorted(arguments.items())))}"
         if call_sig == self._last_call_signature:
-            self._consecutive_duplicates += 1
+            # Only count as duplicate if not a read operation or if it's excessive
+            if not is_read_only:
+                self._consecutive_duplicates += 1
+            elif self._consecutive_duplicates >= 5:  # Allow more reads before flagging
+                self._consecutive_duplicates += 1
         else:
             self._consecutive_duplicates = 0
             self._last_call_signature = call_sig
@@ -119,19 +125,19 @@ class TurnState:
         Returns:
             True if loop indicators are detected.
         """
-        # Same tool+args called 3+ times consecutively
-        if self._consecutive_duplicates >= 2:  # 0-indexed, so 2 = 3 calls
+        # Same tool+args called 4+ times consecutively (increased from 3)
+        if self._consecutive_duplicates >= 3:  # 0-indexed, so 3 = 4 calls
             return True
 
-        # Same result hash repeated 3+ times in last 5 results
-        if len(self.recent_result_hashes) >= 5:
-            recent = self.recent_result_hashes[-5:]
+        # Same result hash repeated 4+ times in last 6 results (more lenient)
+        if len(self.recent_result_hashes) >= 6:
+            recent = self.recent_result_hashes[-6:]
             for h in set(recent):
-                if recent.count(h) >= 3:
+                if recent.count(h) >= 4:
                     return True
 
-        # No new files touched in 5+ iterations with many tool calls
-        return bool(self.iteration >= 5 and not self.files_modified and self.tool_count > 10)
+        # No new files touched in 7+ iterations with many tool calls (increased threshold)
+        return bool(self.iteration >= 7 and not self.files_modified and self.tool_count > 15)
 
     def get_adaptive_limit(self, base_limit: int = 25) -> int:
         """Get the adaptive iteration limit based on progress.

henchman/rag/system.py

@@ -6,6 +6,7 @@ the RAG system in the CLI.
 
 from __future__ import annotations
 
+import asyncio
 from pathlib import Path
 from typing import TYPE_CHECKING
 
@@ -78,6 +79,7 @@ class RagSystem:
         self.git_root = git_root
         self.settings = settings
         self.read_only = read_only
+        self.is_indexing = False
 
         # Get cache directory
         cache_dir = Path(settings.cache_dir) if settings.cache_dir else None
@@ -193,12 +195,37 @@ class RagSystem:
                     f"Could not acquire RAG lock at {self._lock.lock_path}"
                 )
         
+        self.is_indexing = True
         try:
             # Run indexing with lock held
             return self._indexer.index(console=console, force=force)
         finally:
             # Always release the lock
             self._lock.release()
+            self.is_indexing = False
+
+    async def index_async(
+        self,
+        console: Console | None = None,
+        force: bool = False,
+        skip_if_locked: bool = True,
+    ) -> IndexStats | None:
+        """Run indexing operation asynchronously in a separate thread.
+
+        Args:
+            console: Rich console for progress display.
+            force: If True, force full reindex.
+            skip_if_locked: If True and lock cannot be acquired,
+                skip indexing and return None.
+
+        Returns:
+            Statistics about the indexing operation.
+        """
+        loop = asyncio.get_running_loop()
+        return await loop.run_in_executor(
+            None,
+            lambda: self.index(console=console, force=force, skip_if_locked=skip_if_locked)
+        )
 
     def get_stats(self) -> IndexStats:
         """Get current index statistics.
@@ -220,6 +247,7 @@ def initialize_rag(
     settings: RagSettings,
     console: Console | None = None,
     git_root: Path | None = None,
+    index: bool = True,
 ) -> RagSystem | None:
     """Initialize the RAG system if in a git repository.
 
@@ -227,6 +255,7 @@ def initialize_rag(
         settings: RAG settings from configuration.
         console: Rich console for output.
         git_root: Optional pre-computed git root.
+        index: Whether to run indexing immediately (blocking).
 
     Returns:
         RagSystem instance if successful, None if not in a git repo
@@ -253,7 +282,10 @@ def initialize_rag(
 
         rag_system = RagSystem(git_root=root, settings=settings)
 
-        # Run indexing
+        if not index:
+            return rag_system
+
+        # Run indexing (blocking)
         stats = rag_system.index(console=console)
 
         # Show summary

henchman/utils/compaction.py

@@ -259,13 +259,14 @@ class ContextCompactor:
             )
             protected_tokens = TokenCounter.count_messages(protected_msgs)
 
-        # Group unprotected messages into atomic sequences
-        sequences = self._group_into_sequences(unprotected_msgs)
-
         # Separate system messages (always kept)
         system_msgs = [msg for msg in unprotected_msgs if msg.role == "system"]
         system_tokens = TokenCounter.count_messages(system_msgs)
 
+        # Group non-system unprotected messages into atomic sequences
+        non_system_unprotected = [msg for msg in unprotected_msgs if msg.role != "system"]
+        sequences = self._group_into_sequences(non_system_unprotected)
+
         # Calculate budget for unprotected sequences
         # Must fit: system + kept sequences + protected zone
         budget = self.max_tokens - system_tokens - protected_tokens

{henchman_ai-0.1.11.dist-info → henchman_ai-0.1.12.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: henchman-ai
-Version: 0.1.11
+Version: 0.1.12
 Summary: A model-agnostic AI agent CLI - your AI henchman for the terminal
 Project-URL: Homepage, https://github.com/MGPowerlytics/henchman-ai
 Project-URL: Repository, https://github.com/MGPowerlytics/henchman-ai

{henchman_ai-0.1.11.dist-info → henchman_ai-0.1.12.dist-info}/RECORD

@@ -2,21 +2,21 @@ henchman/__init__.py,sha256=P_jCbtgAVbk2hn6uMum2UYkE7ptT361mWRkUZz0xKvk,148
 henchman/__main__.py,sha256=3oRWZvoWON5ErlJFYOOSU5p1PERRyK6MkT2LGEnbb2o,131
 henchman/version.py,sha256=UFJFO9ixJBEALb9BGtb2TE9cid8MpfI03n3BvBeWoiA,161
 henchman/cli/__init__.py,sha256=Gv86a_heuBLqUd-y46JZUyzUaDl5H-9RtcWGr3rMwBw,673
-henchman/cli/app.py,sha256=7fZI6ta4h6FT-EixItDrje4fKUHYc2hpQgL8UZs9Hpk,6682
-henchman/cli/console.py,sha256=BeF-XAS6REn0HzjAvdaM6GBI4XtlVxRY_-FuxoWwcoQ,7921
-henchman/cli/input.py,sha256=0qW36f7f06ct4XXca7ooxkTShID-QXkLtmROh_xso04,4632
+henchman/cli/app.py,sha256=ausKDDrRJ5KgiespK2P9vhX1yn-DxdJhYyBJ6tB5sb4,11507
+henchman/cli/console.py,sha256=S4Jvq0UTmu9KtOkLNsIsvG_8X9eg1Guc6NAh8T_JeNI,8017
+henchman/cli/input.py,sha256=oMKMF1CQCZrON5gqy8mtbYqIoGUvXcBEiDZeTxC9B6s,7129
 henchman/cli/json_output.py,sha256=9kP9S5q0xBgP4HQGTT4P6DDT76F9VVTdEY_KiEpoZnI,2669
 henchman/cli/prompts.py,sha256=m3Velzi2tXBIHinN9jIpU9kDMYL80ngYQsv2EYo7IZU,6647
-henchman/cli/repl.py,sha256=QZ6H4yWkr73dKQeIXihrus1ep6yJQwg1w5X-gRjAYkY,19866
+henchman/cli/repl.py,sha256=fkeaMEGnFaFZ-HIjBLI1DUfos9ebGkHrPUUNMWS_LLU,26535
 henchman/cli/repl.py.backup,sha256=3iagruUgsvtcfpDv1mTAYg4I14X4CaNSEeMQjj91src,15638
 henchman/cli/repl.py.backup2,sha256=-zgSUrnobd_sHq3jG-8NbwPTVlPc3FaqSkv32gAFdPo,11328
 henchman/cli/commands/__init__.py,sha256=8s6NBCPlc4jKTCdvnKJCmdLwRCQ4QLCARjQbr7ICipw,3828
-henchman/cli/commands/builtins.py,sha256=d4wgb3VeWwaWmKtk0MKr5NAvo-OWVgfxAQKpWkJGBFU,5136
-henchman/cli/commands/chat.py,sha256=rrw1ZGVDdfJiNiPSSow2Q2v6I1uU4wnrfFHj9mZOACc,5550
+henchman/cli/commands/builtins.py,sha256=-XOAY0EzvyHYnoOc6QMwVve7aMEWPYiMUUjor4OzBqg,5439
+henchman/cli/commands/chat.py,sha256=ePPRh68ZHHS_l1Uj7fUtjBQrVKOx6WvZQsuIzXdxgjY,6204
 henchman/cli/commands/extensions.py,sha256=r7PfvbBjwBr5WhF8G49p29z7FKx6geRJiR-R67pj6i0,1758
 henchman/cli/commands/mcp.py,sha256=bbW1J9-fIpvDBIba3L1MAkNqCjFBTZnZLNIgf6LjJEA,3554
 henchman/cli/commands/plan.py,sha256=5ZXePoMVIKBxugSnDB6N2TEDpl2xZszQDz9wTQffzpY,2486
-henchman/cli/commands/rag.py,sha256=gG0KJ_ildFB76448hbPEMfsZNhY6RKWrCe0IDPyLsuM,7101
+henchman/cli/commands/rag.py,sha256=sXY7MCZ4UMVzNX2ALVM8wt7q82PZovwVHOSMDfot8jQ,7308
 henchman/cli/commands/skill.py,sha256=azXb6-KXjtZKwHiBV-Ppk6CdJQKZhetr46hNgZ_r45Q,8096
 henchman/cli/commands/unlimited.py,sha256=eFMTwrcUFWbfJnXpwBcRqviYt66tDz4xAYBDcton50Y,2101
 henchman/config/__init__.py,sha256=28UtrhPye0MEmbdvi1jCqO3uIXfmqSAZVWvnpJv-qTo,637
@@ -28,7 +28,7 @@ henchman/core/agent.py,sha256=l9BJO8Zw4bMdUyTDjcZKG84WdZ1Kndm3Y09oUAZFYp0,13475
 henchman/core/agent.py.backup,sha256=Tq0IhWAPMRQTxjETeH7WTosEmzuUVz7um0YbCnuNbLQ,7417
 henchman/core/events.py,sha256=Uijv3NGNV8yJnQfY48u0pBBvEauAEczAbkGARJy8mfI,1423
 henchman/core/session.py,sha256=NkwEG2ZS2uh2ZeX8_LkSN7MwQlBxwhTXjx0BoNUZLDw,12475
-henchman/core/turn.py,sha256=DoSWqIifrrkhzr4KD3zmA1Sq-csNCBflGGEKOc7PfOs,8165
+henchman/core/turn.py,sha256=iRaTr_8hGSGQUt0vqmUE8w5D-drvkLeZlNEHmNUfX0M,8617
 henchman/extensions/__init__.py,sha256=C7LrK50uiHwmLlOGkQyngbFvuUYdCcZEb6ucOklY_ws,310
 henchman/extensions/base.py,sha256=cHUzWu4OGFju9Wr1xAiGHZOOW7eQbcC1-dqEd2Oe3QM,2290
 henchman/extensions/manager.py,sha256=xHxMo0-BxzyFfD3fZgvsiovORYpMM6sPnDPOTfULZSU,6666
@@ -52,7 +52,7 @@ henchman/rag/embedder.py,sha256=J2-cIEIoS2iUh4k6PM-rgl7wkTOXSG1NrOQvXHTQPho,4080
 henchman/rag/indexer.py,sha256=6oVOkv4lD_elACivPL9Noe5zgpterYDZ3f1XlLyyULc,11806
 henchman/rag/repo_id.py,sha256=ZRPKM8fzwmETgrOYwE1PGjRp3c8XQFrR493BrDZlbd8,5755
 henchman/rag/store.py,sha256=eN0Rj2Lo6zJp2iWCXsJ-q24l2T_pnlTF3Oeea60gnfs,8826
-henchman/rag/system.py,sha256=TklAKf3EjsnKDP-C7G5kE6XauQCdHd4uEJbVIkLgZ38,8835
+henchman/rag/system.py,sha256=uEftMJJCy0wlHvt09j2YP7xDdN0if8eCYD4MnS7_Xvc,9869
 henchman/skills/__init__.py,sha256=cvCl6HRxsUdag-RTpMP__Ww_hee37ggpAXQ41wXemEU,149
 henchman/skills/executor.py,sha256=sYss_83zduFLB_AACTSXMZHLA_lv-T1iKHSxelpv13U,1105
 henchman/skills/learner.py,sha256=lzIrLU5_oLbqDYF673F-rwb1IaWeeOqjzcsBGC-IKlM,1644
@@ -73,12 +73,12 @@ henchman/tools/builtins/rag_search.py,sha256=yk0z0mIVRH-yl47uteNXTy76aXP8PLxBq51
 henchman/tools/builtins/shell.py,sha256=Gx8x1jBq1NvERFnc-kUNMovFoWg_i4IrV_askSECfEM,4134
 henchman/tools/builtins/web_fetch.py,sha256=uwgZm0ye3yDuS2U2DPV4D-8bjviYDTKN-cNi7mCMRpw,3370
 henchman/utils/__init__.py,sha256=ayu2XRNx3Fw0z8vbIne63A3gBjxu779QE8sUQsjNnm4,240
-henchman/utils/compaction.py,sha256=jPpJ5tQm-IBn4YChiGrKy8u_K4OJ23lk3Jvq8sNbQYc,22763
+henchman/utils/compaction.py,sha256=ARS0jUDI2adsoCTfJjygRom31N16QtWbRzNXDKzX6cA,22871
 henchman/utils/retry.py,sha256=sobZk9LLGxglSJw_jeNaBYCrvH14YNFrBVyp_OwLWcw,4993
 henchman/utils/tokens.py,sha256=D9H4ciFNH7l1b05IGbw0U0tmy2yF5aItFZyDufGF53k,5665
 henchman/utils/validation.py,sha256=moj4LQXVXt2J-3_pWVH_0-EabyRYApOU2Oh5JSTIua8,4146
-henchman_ai-0.1.11.dist-info/METADATA,sha256=jhhpjwZJDMJW2gdY1PXT8dULA0z9MKeqTcyqbd17Aos,3552
-henchman_ai-0.1.11.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-henchman_ai-0.1.11.dist-info/entry_points.txt,sha256=dtPyd6BzK3A8lmrj1KXTFlHBplIWcWMdryjtR0jw5iU,51
-henchman_ai-0.1.11.dist-info/licenses/LICENSE,sha256=TMoSCCG1I1vCMK-Bjtvxe80E8kIdSdrtuQXYHc_ahqg,1064
-henchman_ai-0.1.11.dist-info/RECORD,,
+henchman_ai-0.1.12.dist-info/METADATA,sha256=Ht1dV7MGoqu7E2XAubPT9sZbNxFepLvA9jGQxw2KTas,3552
+henchman_ai-0.1.12.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+henchman_ai-0.1.12.dist-info/entry_points.txt,sha256=dtPyd6BzK3A8lmrj1KXTFlHBplIWcWMdryjtR0jw5iU,51
+henchman_ai-0.1.12.dist-info/licenses/LICENSE,sha256=TMoSCCG1I1vCMK-Bjtvxe80E8kIdSdrtuQXYHc_ahqg,1064
+henchman_ai-0.1.12.dist-info/RECORD,,