henchman-ai 0.1.11__tar.gz → 0.1.12__tar.gz

henchman_ai-0.1.12/ALPHA_TEST_LOG.md

@@ -0,0 +1,45 @@
+# Henchman Alpha Test Log
+**Date:** 2026-02-02
+**Tester:** Senior Principal QA Lead
+
+## Objectives
+- Verify architectural constraints.
+- specific tool usage patterns.
+- Test self-correction capabilities.
+- Verify context maintenance.
+
+## Issues Found
+
+### 1. Session Management Completely Missing in CLI
+**Severity:** Critical
+**Description:** `app.py` does not initialize `SessionManager` or `Session` for `Repl`. As a result, conversation history is not recorded or saved to disk by default.
+**Impact:** Users lose all conversation history when the CLI exits.
+
+### 2. Session Loading Amnesia
+**Severity:** High
+**Description:** When a session is loaded (manually or via `/chat resume`), the `Agent.messages` history is not automatically synced with the loaded session's history. While `/chat resume` attempts to do this, it doesn't update `Repl.session`, leading to inconsistent state.
+**Impact:** Context loss and failed auto-saves for resumed sessions.
+
+### 4. Interrupted Turn Inconsistency
+**Severity:** High
+**Description:** If a turn is interrupted (e.g., Ctrl+C) during tool execution, the assistant message is recorded in the session with tool calls, but no tool results are added.
+**Impact:** Resuming such a session creates an invalid message sequence for most LLM providers (OpenAI requires responses for all tool calls), causing the next turn to fail with an API error.
+
+### 5. Brittle Tool Execution Loop
+**Severity:** Medium
+**Description:** `Repl` executes tool calls sequentially instead of using `ToolRegistry.execute_batch`.
+**Impact:** Significant performance penalty when multiple independent tools are called in a single turn.
+
+### 6. Duplication Risk in Context Compaction
+**Severity:** Low/Medium
+**Description:** The `ContextCompactor` extracts system messages to prepend them to the result, but also includes them in the first atomic sequence. If the first sequence is kept, the system message is duplicated.
+**Impact:** Minor token waste, but could potentially confuse some sensitive models.
+
+### 7. Missing Tool Confirmation Handler
+**Severity:** Critical (Security)
+**Description:** The CLI does not set a confirmation handler on the `ToolRegistry`. Consequently, tools marked as `WRITE`, `EXECUTE`, or `NETWORK` (like `shell` or `write_file`) are executed immediately without any user oversight.
+**Impact:** Highly dangerous. The agent can run arbitrary shell commands or modify any file without the user being able to stop it.
+
+## Summary for Development Team
+The core agent logic and loop protection are robust, but the **CLI integration layer** is currently an "Alpha" state with broken session persistence and context handling. Priority should be given to wiring up `SessionManager` in `app.py` and ensuring `Agent.messages` is always synced with `Repl.session.messages`.
+

henchman_ai-0.1.12/BETA_TESTING_ISSUES.md

@@ -0,0 +1,55 @@
+# Beta Testing Issues Report
+
+**Date:** 2026-02-02
+**Tester:** Gemini CLI
+
+## Summary
+The Henchman CLI (v0.1.11) shows significant improvements over the Alpha state. Session persistence is functional (files are saved), and tool confirmation workflows are implemented. However, critical CLI commands for managing sessions and MCP servers are missing from the registry, making it impossible to manage sessions or MCP connections interactively.
+
+## Issues Found
+
+### 1. Missing `/chat` Command
+**Severity:** High
+**Description:** The `/chat` command (implemented in `src/henchman/cli/commands/chat.py`) is not registered in `src/henchman/cli/commands/builtins.py`.
+**Impact:** Users cannot save, list, or resume sessions interactively. The `ChatCommand` class exists but is unreachable.
+**Reproduction:**
+```bash
+henchman
+> /chat list
+✗ Unknown command: /chat
+```
+
+### 2. Missing `/mcp` Command
+**Severity:** Medium
+**Description:** The `/mcp` command (implemented in `src/henchman/cli/commands/mcp.py`) is not registered in `src/henchman/cli/commands/builtins.py`.
+**Impact:** Users cannot manage or inspect Model Context Protocol (MCP) servers interactively.
+**Reproduction:**
+```bash
+henchman
+> /mcp list
+✗ Unknown command: /mcp
+```
+
+### 3. Session Resume Requires Tags
+**Severity:** Medium
+**Description:** The `/chat resume` command implementation only supports loading by `tag` (`manager.load_by_tag`). It does not appear to support loading by Session ID. Since sessions are created without tags by default, users cannot easily resume a specific previous session without manually editing the session file to add a tag or implementing a tagging workflow.
+**Impact:** Resuming the "last session" or a specific untitled session is difficult/impossible via the CLI.
+**Location:** `src/henchman/cli/commands/chat.py`, `_resume` method.
+
+### 4. Cosmetic: CLI Self-Identification
+**Severity:** Low
+**Description:** `henchman --version` output identifies as `mlg`.
+**Output:** `mlg, version 0.1.11`
+**Expected:** `henchman, version 0.1.11`
+
+## Verification of Alpha Issues
+
+- **Session Management Missing:** [FIXED] `SessionManager` is correctly initialized in `app.py`, and session files are created in `~/.henchman/sessions`.
+- **Missing Tool Confirmation Handler:** [FIXED] `ToolRegistry.set_confirmation_handler` is called in `Repl.__init__`, and prompts are displayed for dangerous tools (verified with `write_file`).
+- **Session Loading Amnesia:** [PARTIALLY VERIFIED] Could not fully verify due to missing `/chat` command, but code inspection of `ChatCommand._resume` suggests it now correctly syncs `Repl.session` and `Agent.messages`.
+
+## Recommendations
+
+1.  **Register Missing Commands:** Add `ChatCommand()` and `McpCommand()` to the list returned by `get_builtin_commands()` in `src/henchman/cli/commands/builtins.py`.
+2.  **Enhance Resume:** Modify `ChatCommand._resume` to try loading by ID if loading by tag fails, or add a separate `load` subcommand that accepts IDs.
+3.  **Auto-Resume:** Consider an option or flag (e.g., `henchman --resume`) to automatically load the most recent session.

henchman_ai-0.1.12/BETA_TESTING_ISSUES2.md

@@ -0,0 +1,215 @@
+# Henchman Beta Testing Notes
+
+**Tester**: GitHub Copilot (Claude Opus 4.5)  
+**Date**: February 2, 2026  
+**Version Tested**: v0.1.11 (package name: `mlg`)  
+**CLI Location**: `/home/matthew/mlg-cli`
+
+---
+
+## Overview
+
+Henchman is a model-agnostic AI agent CLI. It supports interactive sessions and headless mode with `--prompt`. This document captures observations, issues, and feedback from beta testing.
+
+---
+
+## CLI Options Discovered
+
+```
+Usage: henchman [OPTIONS]
+
+Options:
+  --version                       Show the version and exit.
+  -p, --prompt TEXT               Run with a single prompt and exit
+  --output-format [text|json|stream-json]  Output format for responses
+  --plan                          Start in plan mode (read-only)
+  --help                          Show this message and exit.
+```
+
+---
+
+## Testing Sessions
+
+### Session 1 - Initial Launch (Prior)
+- **Command**: `henchman`
+- **Working Directory**: `/home/matthew/mlg-cli`
+- **Exit Code**: 130 (Ctrl+C interrupt)
+- **Status**: ⚠️ Inconclusive - manual interrupt
+
+### Session 2 - Help & Version Check
+- **Command**: `henchman --help` and `henchman --version`
+- **Result**: ✅ Success - Clean output, proper CLI structure
+- **Version**: 0.1.11
+
+### Session 3 - Simple Workspace Query
+- **Command**: `henchman -p "What files are in this workspace?"`
+- **Result**: ✅ Success - Correctly listed directories and files
+- **Tools Used**: `ls()`
+- **Iterations**: 1/25
+
+### Session 4 - File Reading & Summarization
+- **Command**: `henchman -p "Read .github/copilot-instructions.md and summarize"`
+- **Result**: ✅ Success - Read file, provided accurate 2-sentence summary
+- **Tools Used**: `read_file()`
+- **Quality**: Excellent - understood project context accurately
+
+### Session 5 - Plan Mode (Complex Analysis)
+- **Command**: `henchman --plan -p "What tests would you run to validate Elo?"`
+- **Result**: ✅ Success - Comprehensive analysis with 10 test categories
+- **Tools Used**: `ls()`, `read_file()`, `rag_search()`
+- **Iterations**: 14/25
+- **Note**: Loop detection triggered at iteration 11 ("⚠ Possible loop detected") but recovered gracefully
+
+### Session 6 - Code Generation (File Creation)
+- **Command**: `henchman -p "Create a test file for NBAEloRating"`
+- **Result**: ✅ Success - Created valid, working test file
+- **Tools Used**: `rag_search()`, `read_file()`, `ls()`, `write_file()`
+- **File Created**: `tests/test_henchman_demo.py` (3944 bytes)
+- **Test Verification**: Both tests passed when run with pytest!
+- **User Interaction**: Required "y/n" confirmation for file write (good safety feature)
+
+### Session 7 - JSON Output Format
+- **Command**: `henchman -p "What is 2+2?" --output-format json`
+- **Result**: ✅ Success - Streamed JSON tokens properly
+- **Note**: Output is token-by-token, final line has full response
+
+### Session 8 - Shell Command Execution
+- **Command**: `henchman -p "Run 'echo Hello from Henchman'"`
+- **Result**: ✅ Success - Executed command, showed output
+- **Tools Used**: `shell()`
+- **User Interaction**: Required "y/n" confirmation (good safety feature)
+
+### Session 9 - Multi-Step File Operations
+- **Command**: `henchman -p "Find Python files in plugins/elo and count them"`
+- **Result**: ✅ Success - Found all 15 Python files correctly
+- **Tools Used**: `ls()`, `glob()`, `shell()`
+- **Iterations**: 6/35
+
+---
+
+## Issues Found
+
+### Issue #1: Loop Detection Warning (Minor)
+- **Severity**: Low
+- **Description**: During complex analysis tasks, Henchman triggers "⚠ Possible loop detected" warnings when reading multiple files sequentially.
+- **Observed In**: Session 5 (Plan mode analysis)
+- **Impact**: None - it recovered and continued successfully
+- **Suggestion**: Consider adjusting the loop detection heuristics to differentiate between legitimate sequential file reads and actual loops.
+
+### Issue #2: Version Mismatch Display
+- **Severity**: Very Low (cosmetic)
+- **Description**: `--version` shows `mlg, version 0.1.11` but product is "Henchman"
+- **Expected**: `henchman, version 0.1.11`
+- **Impact**: Confusion about package vs. product naming
+
+### Issue #3: JSON Output Token Streaming
+- **Severity**: Low
+- **Description**: JSON output streams token-by-token which may not be ideal for programmatic consumption
+- **Observed**: `{"type": "content", "data": "2"}` per token
+- **Suggestion**: Consider a `--output-format json-complete` option for full response in single JSON object
+
+---
+
+## Feature Requests
+
+1. **Non-interactive mode flag**: A `--yes` or `-y` flag to auto-approve tool executions for CI/CD pipelines
+2. **Verbosity control**: `--quiet` or `--verbose` flags to control output detail
+3. **Session logging**: Option to log full session to file for debugging
+4. **Context file**: Ability to specify a context file (like copilot-instructions.md) for automatic project conventions
+
+---
+
+## Positive Observations
+
+### ✅ Excellent Code Quality
+The test file Henchman generated was:
+- Properly structured with docstrings
+- Followed existing project conventions
+- Included multiple test cases beyond requirements
+- **Actually passed when run with pytest!**
+
+### ✅ Smart Tool Selection
+- Uses RAG search for semantic queries
+- Falls back to file system operations for concrete tasks
+- Chains tools effectively (ls → read_file → write_file)
+
+### ✅ Good Safety Features
+- Prompts for confirmation before file writes
+- Prompts for confirmation before shell commands
+- Clear display of what tool is being called
+
+### ✅ Context Awareness
+- Understood project structure quickly
+- Read relevant files before generating code
+- Matched existing code style and imports
+
+### ✅ Plan Mode
+- Excellent for read-only analysis
+- Thorough exploration of codebase
+- Generates actionable recommendations
+
+### ✅ Progress Indicators
+- Shows iteration count (e.g., "[Iter 3/25 | 3 calls | 2K tokens]")
+- Indicates token usage and protection status
+- Shows "✓ progress" vs "⚠ spinning" status
+
+---
+
+## Comparison Notes
+
+As an agentic coding AI myself, here's my evaluation:
+
+- [x] **Tool Usage**: Excellent - smart tool selection, effective chaining
+- [x] **Context Awareness**: Excellent - understands project structure
+- [x] **Autonomy**: Good - handles multi-step tasks independently
+- [x] **Error Recovery**: Good - recovered from loop detection warnings
+- [x] **Code Quality**: Excellent - generated working, idiomatic code
+- [x] **Communication**: Good - clear about what it's doing
+- [x] **Persistence**: Good - follows through on complex tasks
+
+---
+
+## Testing Checklist
+
+- [x] Basic CLI functionality
+- [x] File reading/editing capabilities
+- [x] Terminal command execution
+- [ ] Multi-file refactoring (not tested yet)
+- [ ] Error handling and recovery (partially tested)
+- [x] Project-specific conventions
+- [ ] Database operations (not tested yet)
+- [x] Test execution (generated tests that work!)
+- [ ] Long-running task management (not tested yet)
+
+---
+
+## Recommendations for Henchman Team
+
+1. **Fix version string**: Change from `mlg` to `henchman` in `--version` output
+2. **Tune loop detection**: Current threshold may be too aggressive for legitimate file exploration
+3. **Add batch mode**: For CI/CD integration, add `--yes` flag to skip confirmations
+4. **Document tool set**: List available tools (ls, read_file, write_file, shell, rag_search, glob) in docs
+5. **Consider token limits**: Show remaining context budget more prominently
+
+---
+
+## Overall Assessment
+
+**Rating: 8.5/10** ⭐⭐⭐⭐
+
+Henchman is a solid, well-designed agentic AI CLI. The headless mode (`-p`) is particularly useful for scripting. Code generation quality is impressive - the test file it created actually worked! The safety features (confirmations for writes/commands) are appropriate for a beta. Minor polish issues exist but don't impact functionality.
+
+**Would recommend for**: Developers who want CLI-based AI assistance for file exploration, code generation, and analysis tasks.
+
+---
+
+## Changelog
+
+| Date | Notes |
+|------|-------|
+| 2026-02-02 | Created initial beta testing document |
+| 2026-02-02 | Completed comprehensive testing - 9 sessions, 3 issues found, overall positive |
+
+---
+
+*Testing complete. Document may be updated with additional findings.*

{henchman_ai-0.1.11 → henchman_ai-0.1.12}/PKG-INFO

@@ -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 → henchman_ai-0.1.12}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "henchman-ai"
-version = "0.1.11"
+version = "0.1.12"
 description = "A model-agnostic AI agent CLI - your AI henchman for the terminal"
 readme = "README.md"
 license = "MIT"

henchman_ai-0.1.12/src/henchman/cli/app.py

@@ -0,0 +1,322 @@
+"""MLG CLI application entry point."""
+
+from __future__ import annotations
+
+import asyncio
+import os
+from typing import TYPE_CHECKING
+
+import anyio
+import click
+from rich.console import Console
+
+from henchman.version import VERSION
+
+if TYPE_CHECKING:
+    from henchman.providers.base import ModelProvider
+
+console = Console()
+
+
+def _get_provider() -> ModelProvider:
+    """Get the configured model provider.
+
+    Returns:
+        A ModelProvider instance.
+
+    Raises:
+        click.ClickException: If no provider is configured.
+    """
+    from henchman.providers import DeepSeekProvider, get_default_registry
+
+    # Check environment for API key
+    api_key = os.environ.get("DEEPSEEK_API_KEY") or os.environ.get("HENCHMAN_API_KEY")
+
+    if api_key:
+        return DeepSeekProvider(api_key=api_key)
+
+    # Try to load from settings
+    try:
+        from henchman.config import load_settings
+
+        settings = load_settings()
+        registry = get_default_registry()
+
+        provider_name = settings.providers.default or "deepseek"
+        provider_settings = getattr(settings.providers, provider_name, None)
+
+        if provider_settings:
+            return registry.create(
+                provider_name,
+                api_key=getattr(provider_settings, "api_key", None) or "",
+                model=getattr(provider_settings, "model", None),
+            )
+    except Exception:  # pragma: no cover
+        pass
+
+    raise click.ClickException(  # pragma: no cover
+        "No API key configured. Set DEEPSEEK_API_KEY or configure in ~/.henchman/settings.yaml"
+    )
+
+
+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, 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()
+    settings = load_settings()
+
+    # Load context from MLG.md files
+    context_loader = ContextLoader()
+    system_prompt = context_loader.load()
+
+    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, console=console, index=False)
+    if rag_system:
+        repl.tool_registry.register(rag_system.search_tool)
+        repl.rag_system = rag_system
+
+    # Set plan mode if requested
+    if plan_mode and repl.session:
+        repl.session.plan_mode = True
+        repl.tool_registry.set_plan_mode(True)
+        # Add plan mode prompt to system prompt
+        from henchman.cli.commands.plan import PLAN_MODE_PROMPT
+        repl.agent.system_prompt += PLAN_MODE_PROMPT
+
+    if output_format == "text":
+        anyio.run(repl.run)
+    else:  # pragma: no cover
+        console.print(
+            "[yellow]Warning: JSON output formats not supported in interactive mode. "
+            "Using text format.[/yellow]"
+        )
+        anyio.run(repl.run)
+
+
+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, 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()
+    settings = load_settings()
+
+    # Load context from MLG.md files
+    context_loader = ContextLoader()
+    system_prompt = context_loader.load()
+
+    # Add plan mode prompt if requested
+    if plan_mode:  # pragma: no cover
+        from henchman.cli.commands.plan import PLAN_MODE_PROMPT
+        system_prompt += PLAN_MODE_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, index=False)  # No console output in headless
+    if rag_system:
+        repl.tool_registry.register(rag_system.search_tool)
+        repl.rag_system = rag_system
+
+    # Set plan mode if requested
+    if plan_mode and repl.session:  # pragma: no cover
+        repl.session.plan_mode = True
+        repl.tool_registry.set_plan_mode(True)
+
+    async def run_single_prompt_text() -> None:  # pragma: no cover
+        """Process a single prompt and exit with text output."""
+        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)
+        
+        # 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 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)
+    elif output_format == "json":
+        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="henchman")
+@click.option("-p", "--prompt", help="Run with a single prompt and exit")
+@click.option(
+    "--output-format",
+    type=click.Choice(["text", "json", "stream-json", "json-complete"]),
+    default="text",
+    help="Output format for responses",
+)
+@click.option(
+    "--plan",
+    is_flag=True,
+    default=False,
+    help="Start in plan mode (read-only)",
+)
+@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, yes)
+    else:
+        _run_interactive(output_format, plan, yes)
+
+
+def main() -> None:  # pragma: no cover
+    """Main entry point for the CLI."""
+    cli()
+
+
+if __name__ == "__main__":  # pragma: no cover
+    main()

{henchman_ai-0.1.11 → henchman_ai-0.1.12}/src/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(),