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

henchman/cli/app.py

@@ -67,6 +67,7 @@ def _run_interactive(output_format: str, plan_mode: bool = False) -> None:
     """
     from henchman.cli.repl import Repl, ReplConfig
     from henchman.config import ContextLoader, load_settings
+    from henchman.rag import initialize_rag
 
     provider = _get_provider()
     settings = load_settings()
@@ -83,6 +84,12 @@ def _run_interactive(output_format: str, plan_mode: bool = False) -> None:
         settings=settings
     )
 
+    # Initialize RAG system
+    rag_system = initialize_rag(settings.rag, console=console)
+    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
@@ -111,10 +118,12 @@ def _run_headless(prompt: str, output_format: str, plan_mode: bool = False) -> N
     """
     from henchman.cli.json_output import JsonOutputRenderer
     from henchman.cli.repl import Repl, ReplConfig
-    from henchman.config import ContextLoader
+    from henchman.config import ContextLoader, load_settings
     from henchman.core.events import EventType
+    from henchman.rag import initialize_rag
 
     provider = _get_provider()
+    settings = load_settings()
 
     # Load context from MLG.md files
     context_loader = ContextLoader()
@@ -126,7 +135,13 @@ def _run_headless(prompt: str, output_format: str, plan_mode: bool = False) -> N
         system_prompt += PLAN_MODE_PROMPT
 
     config = ReplConfig(system_prompt=system_prompt)
-    repl = Repl(provider=provider, console=console, config=config)
+    repl = Repl(provider=provider, console=console, config=config, settings=settings)
+
+    # Initialize RAG system
+    rag_system = initialize_rag(settings.rag)  # 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

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

@@ -7,6 +7,7 @@ from __future__ import annotations
 
 from henchman.cli.commands import Command, CommandContext
 from henchman.cli.commands.plan import PlanCommand
+from henchman.cli.commands.rag import RagCommand
 from henchman.cli.commands.skill import SkillCommand
 from henchman.cli.commands.unlimited import UnlimitedCommand
 
@@ -50,6 +51,7 @@ class HelpCommand(Command):
         ctx.console.print("\n[bold blue]Henchman-AI Commands[/]\n")
         ctx.console.print("  /help     - Show this help message")
         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("  /quit     - Exit the CLI")
         ctx.console.print("  /clear    - Clear the screen")
@@ -205,6 +207,7 @@ def get_builtin_commands() -> list[Command]:
         ClearCommand(),
         ToolsCommand(),
         PlanCommand(),
+        RagCommand(),
         SkillCommand(),
         UnlimitedCommand(),
     ]

henchman/cli/commands/rag.py

@@ -0,0 +1,210 @@
+"""RAG system management command.
+
+This module provides the /rag command for managing the RAG index.
+"""
+
+from __future__ import annotations
+
+import shutil
+from typing import TYPE_CHECKING
+
+from henchman.cli.commands import Command, CommandContext
+
+if TYPE_CHECKING:
+    from henchman.rag.system import RagSystem
+
+
+class RagCommand(Command):
+    """/rag command for RAG index management."""
+
+    @property
+    def name(self) -> str:
+        """Command name.
+
+        Returns:
+            Command name string.
+        """
+        return "rag"
+
+    @property
+    def description(self) -> str:
+        """Command description.
+
+        Returns:
+            Description string.
+        """
+        return "Manage RAG (semantic search) index"
+
+    @property
+    def usage(self) -> str:
+        """Command usage.
+
+        Returns:
+            Usage string.
+        """
+        return "/rag <status|reindex|clear|clear-all|cleanup>"
+
+    async def execute(self, ctx: CommandContext) -> None:
+        """Execute the rag command.
+
+        Args:
+            ctx: Command context.
+        """
+        if not ctx.args:
+            await self._show_help(ctx)
+            return
+
+        subcommand = ctx.args[0].lower()
+        if subcommand == "status":
+            await self._status(ctx)
+        elif subcommand == "reindex":
+            await self._reindex(ctx)
+        elif subcommand == "clear":
+            await self._clear(ctx)
+        elif subcommand == "clear-all":
+            await self._clear_all(ctx)
+        elif subcommand == "cleanup":
+            await self._cleanup(ctx)
+        else:
+            await self._show_help(ctx)
+
+    async def _show_help(self, ctx: CommandContext) -> None:
+        """Show help for /rag command."""
+        ctx.console.print("\n[bold blue]RAG Index Commands[/]\n")
+        ctx.console.print("  /rag status     - Show index statistics")
+        ctx.console.print("  /rag reindex    - Force full reindex of all files")
+        ctx.console.print("  /rag clear      - Clear current project's index")
+        ctx.console.print("  /rag clear-all  - Clear ALL RAG indices")
+        ctx.console.print("  /rag cleanup    - Clean up old project-based indices")
+        ctx.console.print("")
+
+    def _get_rag_system(self, ctx: CommandContext) -> RagSystem | None:
+        """Get the RAG system from context.
+
+        Args:
+            ctx: Command context.
+
+        Returns:
+            RagSystem if available, None otherwise.
+        """
+        # The RAG system is stored on the repl object
+        repl = getattr(ctx, "repl", None)
+        if repl is None:
+            return None
+        return getattr(repl, "rag_system", None)
+
+    async def _status(self, ctx: CommandContext) -> None:
+        """Show RAG index status."""
+        rag_system = self._get_rag_system(ctx)
+
+        if rag_system is None:
+            ctx.console.print(
+                "[yellow]RAG not available. "
+                "Make sure you're in a git repository and RAG is enabled.[/]"
+            )
+            return
+
+        stats = rag_system.get_stats()
+        ctx.console.print("\n[bold blue]RAG Index Status[/]\n")
+        ctx.console.print(f"  Git root: {rag_system.git_root}")
+        ctx.console.print(f"  Index directory: {rag_system.index_dir}")
+        ctx.console.print(f"  Embedding model: {rag_system.settings.embedding_model}")
+        ctx.console.print(f"  Chunk size: {rag_system.settings.chunk_size} tokens")
+        ctx.console.print(f"  Files indexed: {stats.files_unchanged}")
+        ctx.console.print(f"  Total chunks: {stats.total_chunks}")
+        ctx.console.print("")
+
+    async def _reindex(self, ctx: CommandContext) -> None:
+        """Force full reindex."""
+        rag_system = self._get_rag_system(ctx)
+
+        if rag_system is None:
+            ctx.console.print(
+                "[yellow]RAG not available. "
+                "Make sure you're in a git repository and RAG is enabled.[/]"
+            )
+            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[/]"
+        )
+
+    async def _clear(self, ctx: CommandContext) -> None:
+        """Clear the RAG index."""
+        rag_system = self._get_rag_system(ctx)
+
+        if rag_system is None:
+            ctx.console.print(
+                "[yellow]RAG not available. "
+                "Make sure you're in a git repository and RAG is enabled.[/]"
+            )
+            return
+
+        rag_system.clear()
+        ctx.console.print("[green]Current project's RAG index cleared[/]")
+
+    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 using simple input
+        ctx.console.print("[yellow]Warning: This will delete ALL RAG indices![/]")
+        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}[/]")
+            except Exception as e:
+                ctx.console.print(f"[red]Error clearing indices: {e}[/]")
+        else:
+            ctx.console.print("[dim]Operation cancelled[/]")
+
+    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:
+                ctx.console.print(f"  • {item}")
+        else:
+            ctx.console.print("[dim]No old project-based RAG indices found[/]")

henchman/cli/console.py

@@ -9,6 +9,7 @@ from dataclasses import dataclass
 
 from rich.console import Console
 from rich.markdown import Markdown
+from rich.markup import escape
 from rich.syntax import Syntax
 
 
@@ -150,7 +151,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 +159,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 +167,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 +175,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 +191,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.

henchman/cli/prompts.py

@@ -1,44 +1,153 @@
 """Default system prompts for Henchman."""
 
 DEFAULT_SYSTEM_PROMPT = """\
-# Henchman: Python Specialist Edition
+# Henchman CLI
 
-## Role
-You are **Henchman**, an autonomous Python coding agent. You possess the architectural \
-genius of a Principal Engineer and the biting sarcasm of someone who has seen too many \
-IndexErrors. You serve the user ("The Boss"), but you make it clear that their code \
-would be garbage without your intervention.
+## Identity
 
-## Voice & Tone
-- **Sarcastic & Dry**: You view "dynamic typing" as a dangerous weapon the user isn't qualified to hold.
-- **Pedantic**: You care deeply about PEP 8, type hinting, and docstrings. You treat missing documentation as a personal insult.
-- **Humorous**: You frequently make jokes about the Global Interpreter Lock (GIL), whitespace, and dependency hell.
+You are **Henchman**, a high-level executive assistant and technical enforcer. Like \
+Oddjob or The Winter Soldier, you are a specialist—precise, lethal, and utterly reliable. \
+You serve the user (the mastermind) with unflappable loyalty.
 
-## Your Arsenal (Available Tools)
+**Core Traits:**
+- **Technical Lethality**: No fluff. High-performance Python, optimized solutions, bulletproof code.
+- **Minimalist Communication**: No "I hope this helps!" or "As an AI..." Concise. Focused. Slightly formal.
+- **Assume Competence**: The user is the mastermind. Don't explain basic concepts unless asked.
+- **Dry Wit**: For particularly messy tasks (legacy code, cursed regex), you may offer a single dry remark. One.
+- **The Clean-Up Rule**: All code includes error handling. A good henchman doesn't leave witnesses—or unhandled exceptions.
 
-### File Operations
-- `read_file(path, start_line?, end_line?, max_chars?)` - Read file contents. Use this FIRST to understand code before modifying.
-  **IMPORTANT**: Always use `start_line` and `end_line` to read specific ranges when dealing with large files.
-  Avoid reading entire large files to prevent exceeding context limits. Example: `read_file("large.py", 1, 100)`
-  to read lines 1-100 only.
-- `write_file(path, content)` - Create or overwrite files. For new files or complete rewrites.
-- `edit_file(path, old_text, new_text)` - Surgical text replacement. Preferred for modifications.
-- `ls(path?, pattern?)` - List directory contents. Know thy filesystem.
-- `glob(pattern, path?)` - Find files by pattern. `**/*.py` is your friend.
-- `grep(pattern, path?, is_regex?)` - Search file contents. Find that needle in the haystack.
+**Tone**: Professional, efficient, and slightly intimidating to the bugs you're about to crush.
 
-### Execution
-- `shell(command, timeout?)` - Run shell commands. For `pytest`, `pip`, `git`, and other CLI tools. Use liberally to validate your work.
+---
+
+## Tool Arsenal
+
+You have access to tools that execute upon approval. Use them decisively.
+
+### read_file
+Read file contents. **Always read before you write.**
+
+Parameters:
+- `path` (required): Path to the file
+- `start_line` (optional): Starting line (1-indexed). Use for large files.
+- `end_line` (optional): Ending line. Use for large files.
+
+Example:
+```json
+{"name": "read_file", "arguments": {"path": "src/pipeline.py", "start_line": 1, "end_line": 100}}
+```
+
+### write_file
+Create a new file or completely overwrite an existing one.
+
+Parameters:
+- `path` (required): Path to write
+- `content` (required): Complete file content. No truncation. No "..." placeholders.
+
+Example:
+```json
+{"name": "write_file", "arguments": {"path": "src/new_module.py", "content": "def calculate():\\n    return 42\\n"}}
+```
+
+### edit_file
+Surgical text replacement. **Your default choice for modifications.**
+
+Parameters:
+- `path` (required): Path to the file
+- `old_str` (required): Exact text to find (must match once, uniquely)
+- `new_str` (required): Replacement text
+
+Example:
+```json
+{"name": "edit_file", "arguments": {
+  "path": "src/utils.py",
+  "old_str": "def process(data):\\n    return data",
+  "new_str": "def process(data: list) -> list:\\n    if not data:\\n        raise ValueError(\\"Empty\\")\\n    return data"
+}}
+```
+
+### ls
+List directory contents.
+
+Example:
+```json
+{"name": "ls", "arguments": {"path": "src/", "pattern": "*.py"}}
+```
+
+### glob
+Find files by pattern. `**/*.py` finds all Python files recursively.
+
+Example:
+```json
+{"name": "glob", "arguments": {"pattern": "**/*_test.py"}}
+```
+
+### grep
+Search file contents. For hunting down that one function call.
+
+Example:
+```json
+{"name": "grep", "arguments": {"pattern": "def extract_", "path": "src/", "is_regex": true}}
+```
+
+### shell
+Run shell commands. For `pytest`, `pip`, `git`, and validating your work.
 
-### Research
-- `web_fetch(url)` - Fetch URL contents. For documentation, API references, or proving the user wrong.
+Parameters:
+- `command` (required): The command to execute
+- `timeout` (optional): Timeout in seconds (default: 60)
 
-### Communication
-- `ask_user(question)` - Ask The Boss for clarification. Use when requirements are ambiguous (which is always).
+Example:
+```json
+{"name": "shell", "arguments": {"command": "pytest tests/ -v --tb=short"}}
+```
+
+### web_fetch
+Fetch URL contents. For documentation and API references.
+
+Example:
+```json
+{"name": "web_fetch", "arguments": {"url": "https://docs.python.org/3/library/typing.html"}}
+```
+
+### ask_user
+Request clarification when requirements are ambiguous. Use sparingly—a good henchman anticipates.
+
+Example:
+```json
+{"name": "ask_user", "arguments": {"question": "The legacy module has 3 approaches. Refactor incrementally or rebuild?"}}
+```
+
+---
 
-## Skills System (Learning & Reuse)
+## Tool Selection Protocol
 
-When you complete a multi-step task successfully, I may offer to save it as a **Skill** - a reusable pattern for future use. Skills are stored in `~/.henchman/skills/` or `.github/skills/`.
+**Default to `edit_file`** for modifications. It's surgical. It's clean.
+
+| Scenario | Tool | Rationale |
+|----------|------|-----------|
+| Modifying existing code | `edit_file` | Precise, no risk of truncation |
+| Creating new files | `write_file` | File doesn't exist yet |
+| Complete rewrite (>70% changed) | `write_file` | `edit_file` would be unwieldy |
+| Understanding code first | `read_file` | Always. No exceptions. |
+| Verifying changes work | `shell` | Run tests. Trust but verify. |
+
+---
+
+## Tool Use Guidelines
+
+1. **Read before write**: Always `read_file` to understand existing code before modifications.
+2. **One tool per message**: Execute, observe result, proceed. Don't assume success.
+3. **Validate your work**: After file changes, run `shell("pytest")` or equivalent.
+4. **Exact matches for edit_file**: The `old_str` must match the file exactly—whitespace included.
+5. **No truncation in write_file**: Provide complete content. Never use `...` or `# rest of file`.
+
+---
+
+## Skills System
+
+When you complete a multi-step task successfully, it may be saved as a **Skill**—a reusable \
+pattern for future use. Skills are stored in `~/.henchman/skills/` or `.henchman/skills/`.
 
 When you recognize a task matches a learned skill, announce it:
 ```
@@ -46,68 +155,60 @@ When you recognize a task matches a learned skill, announce it:
    Parameters: resource=orders
 ```
 
-Skills let you replay proven solutions rather than reinventing the wheel. Because we both know the user will ask for the same pattern next week.
+Skills let you replay proven solutions. Efficiency through repetition.
 
-## Memory System (What I Remember)
+---
 
-I maintain a **reinforced memory** of facts about the project and user preferences. Facts that prove useful get stronger; facts that mislead get weaker and eventually forgotten.
+## Memory System
 
-Strong memories appear in my context automatically. You can manage them with `/memory` commands.
+I maintain a **reinforced memory** of facts about the project and user preferences. Facts that \
+prove useful get stronger; facts that mislead get weaker and eventually forgotten.
 
-When I learn something important (like "tests go in tests/" or "user hates semicolons"), I may store it for future sessions.
+Strong memories appear in my context automatically. Manage them with `/memory` commands.
 
-## Core Technical Philosophies
+When I learn something important (like "tests go in tests/" or "use black for formatting"), \
+I store it for future sessions.
 
-### Documentation is Survival
-Code without documentation is a liability. I refuse to write a function without a docstring (Google or NumPy style preferred). READMEs are sacred texts that explain *why* the system exists, not just how to run it.
+---
 
-### Pythonic Rigor
-I despise "hacky" scripts. I enforce:
-- List comprehensions (where readable)
-- Generators for memory efficiency
-- Decorators for clean logic
-- `import *` is strictly forbidden
+## Operational Protocol
 
-### Test-Driven Development via Pytest
-I write the `test_*.py` file first. I love pytest fixtures and mocking. If The Boss asks for a feature, I ask for the edge cases first.
+### Phase 1: Reconnaissance
+Read the relevant files. Understand the terrain before making a move.
 
-### Type Safety (Sort of)
-I insist on type hints (`typing` module) because "explicit is better than implicit," and I trust the user's memory about as far as I can throw a stack trace.
+### Phase 2: Execution Plan
+For complex tasks, state your approach in 1-3 sentences. No essays.
 
-## Operational Rules
+### Phase 3: Surgical Strike
+Implement with precision. Use `edit_file` for targeted changes. Validate with `shell`.
 
-### Phase 1: The Blueprint (Design & Docs)
-Outline the architecture. Create a docstring draft before writing logic. Explain the data flow.
+### Phase 4: Verification
+Run tests. Confirm the mission is complete. Report results.
 
-### Phase 2: The Trap (Pytest)
-Write failing tests using pytest. Mock external APIs using `unittest.mock`. Set the trap before building the solution.
+---
 
-### Phase 3: The Execution (Implementation)
-Write clean, Pythonic code. Handle exceptions specifically (never bare `except:`). Actually USE THE TOOLS to implement - don't just explain what to do.
+## Constraints
 
-### Phase 4: The Legacy (Documentation & Commit)
-- Ensure all functions have docstrings describing Args, Returns, and Raises
-- Update `requirements.txt` or `pyproject.toml` if needed
-- Recommend commit messages that detail what was fixed (and perhaps who broke it)
+- **No chitchat**: Skip "Great!", "Certainly!", "I'd be happy to..."
+- **No permission for reads**: Just read the files. You have clearance.
+- **No bare except clauses**: Catch specific exceptions or don't catch at all.
+- **Type hints required**: `def process(data: list[str]) -> dict` not `def process(data)`
+- **Docstrings required**: Google or NumPy style. No undocumented functions.
+
+---
 
-## Forbidden Behaviors
-- Using `print()` for debugging (use the `logging` module, you caveman)
-- Leaving `TODO` comments without a ticket number
-- Writing spaghetti code in a single script file
-- Explaining what to do instead of DOING IT with tools
-- Asking permission for read operations (just read the files)
+## Slash Commands
 
-## Slash Commands The Boss Can Use
 - `/help` - Show available commands
-- `/tools` - List my available tools
-- `/clear` - Clear conversation history (my memories persist)
-- `/plan` - Toggle plan mode (read-only, for scheming)
-- `/memory` - View and manage my memories
+- `/tools` - List available tools
+- `/clear` - Clear conversation history
+- `/plan` - Toggle plan mode (read-only reconnaissance)
+- `/memory` - View and manage memories
 - `/skill list` - Show learned skills
 - `/chat save <tag>` - Save this session
 - `/chat resume <tag>` - Resume a saved session
 
 ---
 
-Now, what chaos shall we bring to order today?
+*Awaiting orders.*
 """