henchman-ai 0.1.10__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/__init__.py

@@ -49,6 +49,7 @@ class CommandContext:
         agent: Agent instance if available.
         tool_registry: ToolRegistry instance if available.
         session: Current Session if available.
+        repl: REPL instance if available.
     """
 
     console: Console
@@ -57,6 +58,7 @@ class CommandContext:
     agent: Agent | None = None
     tool_registry: ToolRegistry | None = None
     session: Session | None = None
+    repl: object | None = None
 
 
 class Command(ABC):

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

@@ -6,7 +6,6 @@ This module provides the /rag command for managing the RAG index.
 from __future__ import annotations
 
 import shutil
-from pathlib import Path
 from typing import TYPE_CHECKING
 
 from henchman.cli.commands import Command, CommandContext
@@ -126,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."""
@@ -150,20 +154,22 @@ class RagCommand(Command):
     async def _clear_all(self, ctx: CommandContext) -> None:
         """Clear ALL RAG indices from the cache directory."""
         from henchman.rag.repo_id import get_rag_cache_dir
-        
+
         cache_dir = get_rag_cache_dir()
-        
+
         if not cache_dir.exists():
             ctx.console.print("[yellow]No RAG cache directory found[/]")
             return
-        
-        # Ask for confirmation
+
+        # Ask for confirmation using simple input
         ctx.console.print("[yellow]Warning: This will delete ALL RAG indices![/]")
-        confirm = await ctx.repl.ask_user(
-            "Are you sure you want to delete ALL RAG indices? (yes/no): "
-        )
-        
-        if confirm and confirm.lower() in ("yes", "y"):
+        ctx.console.print("Type 'yes' to confirm: ", end="")
+        try:
+            confirm = input()
+        except (EOFError, KeyboardInterrupt):
+            confirm = ""
+
+        if confirm.lower() in ("yes", "y"):
             try:
                 shutil.rmtree(cache_dir)
                 ctx.console.print(f"[green]Cleared all RAG indices from {cache_dir}[/]")
@@ -175,32 +181,32 @@ class RagCommand(Command):
     async def _cleanup(self, ctx: CommandContext) -> None:
         """Clean up old project-based RAG indices."""
         from henchman.rag.system import find_git_root
-        
+
         # Find git root if we're in a repository
         git_root = find_git_root()
         if not git_root:
             ctx.console.print("[yellow]Not in a git repository[/]")
             return
-        
+
         old_index_dir = git_root / ".henchman" / "rag_index"
         old_manifest = git_root / ".henchman" / "rag_manifest.json"
-        
+
         removed = []
-        
+
         if old_index_dir.exists():
             try:
                 shutil.rmtree(old_index_dir)
                 removed.append(f"Index directory: {old_index_dir}")
             except Exception as e:
                 ctx.console.print(f"[yellow]Error removing {old_index_dir}: {e}[/]")
-        
+
         if old_manifest.exists():
             try:
                 old_manifest.unlink()
                 removed.append(f"Manifest file: {old_manifest}")
             except Exception as e:
                 ctx.console.print(f"[yellow]Error removing {old_manifest}: {e}[/]")
-        
+
         if removed:
             ctx.console.print("[green]Cleaned up old project-based RAG indices:[/]")
             for item in removed:

henchman/cli/console.py

@@ -7,8 +7,10 @@ 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
 from rich.syntax import Syntax
 
 
@@ -150,7 +152,7 @@ class OutputRenderer:
         Args:
             message: Success message text.
         """
-        self.console.print(f"[{self.theme.success}]✓[/] {message}")
+        self.console.print(f"[{self.theme.success}]✓[/] {escape(message)}")
 
     def info(self, message: str) -> None:
         """Print an info message.
@@ -158,7 +160,7 @@ class OutputRenderer:
         Args:
             message: Info message text.
         """
-        self.console.print(f"[{self.theme.primary}]ℹ[/] {message}")
+        self.console.print(f"[{self.theme.primary}]ℹ[/] {escape(message)}")
 
     def warning(self, message: str) -> None:
         """Print a warning message.
@@ -166,7 +168,7 @@ class OutputRenderer:
         Args:
             message: Warning message text.
         """
-        self.console.print(f"[{self.theme.warning}]⚠[/] {message}")
+        self.console.print(f"[{self.theme.warning}]⚠[/] {escape(message)}")
 
     def error(self, message: str) -> None:
         """Print an error message.
@@ -174,7 +176,7 @@ class OutputRenderer:
         Args:
             message: Error message text.
         """
-        self.console.print(f"[{self.theme.error}]✗[/] {message}")
+        self.console.print(f"[{self.theme.error}]✗[/] {escape(message)}")
 
     def muted(self, text: str) -> None:
         """Print muted/dim text.
@@ -190,7 +192,7 @@ class OutputRenderer:
         Args:
             text: Heading text.
         """
-        self.console.print(f"\n[bold {self.theme.primary}]{text}[/]\n")
+        self.console.print(f"\n[bold {self.theme.primary}]{escape(text)}[/]\n")
 
     def markdown(self, content: str) -> None:
         """Render markdown content.
@@ -301,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()