henchman-ai 0.1.7__tar.gz → 0.1.9__tar.gz

henchman_ai-0.1.9/CHANGELOG.md

@@ -0,0 +1,172 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [0.1.9] - 2026-01-28
+
+### Added
+
+- **Error Handling & Recovery**
+  - Added retry utilities with exponential backoff (`henchman.utils.retry`)
+  - NETWORK tools now automatically retry on transient failures (ConnectionError, TimeoutError, OSError)
+  - Configurable retry settings: `network_retries`, `retry_base_delay`, `retry_max_delay` in ToolSettings
+  - `RetryConfig` dataclass for fine-grained retry configuration
+  - `with_retry` decorator and `retry_async` function for custom retry logic
+
+- **Batch Operations**
+  - Added `execute_batch()` method to ToolRegistry for parallel tool execution
+  - Independent tool calls now execute concurrently using `asyncio.gather()`
+  - `BatchResult` dataclass with success/failure counts and individual results
+  - Batch execution continues even when some tools fail
+
+## [0.1.8] - 2024-01-XX
+
+### Fixed
+
+- **Safety & Stability**
+  - Added safety limits to tools and compactor to prevent excessive resource usage
+  - Switched safety limits from character-based to token-based for better model compatibility
+  - Fixed indentation and syntax issues in tool implementations
+  - Enhanced Python 3.10 compatibility (asyncio.TimeoutError handling)
+
+- **User Interface**
+  - Ctrl+C now exits cleanly when waiting for user input at the prompt (prompt_toolkit key binding)
+  - Escape key now exits gracefully (no crash) when pressed on empty buffer
+  - Added newline after Henchman finishes talking or after tool execution for improved readability
+
+### Added
+
+- **Testing & Quality**
+  - Comprehensive integration tests for token management, tool calls, and validation
+  - Enhanced test coverage for keyboard interrupt handling
+  - Added tests for Ctrl+C and Escape key behavior in input bindings
+  - GitHub Actions workflows for CI/CD pipeline
+
+- **Documentation**
+  - MkDocs documentation site with Material theme
+  - Updated implementation plans and progress reports
+
+## [0.1.7] - 2024-01-XX
+
+### Fixed
+- Switched safety limits from character-based to token-based
+- Fixed indentation and syntax issues
+
+## [0.1.6] - 2024-01-XX
+
+### Fixed
+- Added safety limits to tools and compactor
+
+## [0.1.5] - 2024-01-XX
+
+### Added
+- Integration tests for token management
+
+## [0.1.4] - 2024-01-XX
+
+### Added
+- Enhanced test coverage
+
+## [0.1.3] - 2024-01-XX
+
+### Added
+- Keyboard interrupt handling improvements
+
+## [0.1.2] - 2024-01-XX
+
+### Added
+- Python 3.10 compatibility fixes
+
+## [0.1.1] - 2024-01-XX
+
+### Added
+- GitHub Actions workflows
+- CHANGELOG file
+
+## [0.1.0] - 2024-01-XX
+
+### Added
+
+- **Core Agent System**
+  - Agent class with streaming event architecture
+  - Event-driven processing (CONTENT, THOUGHT, TOOL_CALL_REQUEST, etc.)
+  - Tool execution with confirmation workflow
+  - Session management with auto-save
+
+- **Provider System**
+  - DeepSeek provider (default)
+  - OpenAI-compatible base provider
+  - Anthropic provider with native API
+  - Ollama provider for local models
+  - Provider registry for dynamic provider creation
+
+- **Built-in Tools**
+  - `read_file` - Read file contents
+  - `write_file` - Write to files
+  - `edit_file` - Surgical file edits
+  - `ls` - List directory contents
+  - `glob` - Find files by pattern
+  - `grep` - Search file contents
+  - `shell` - Execute shell commands
+  - `web_fetch` - Fetch web pages
+
+- **Interactive REPL**
+  - Rich terminal UI with theming
+  - Slash commands (/help, /quit, /clear, /tools, /chat)
+  - File references with @filename syntax
+  - Shell command execution with !command syntax
+  - Session save/resume functionality
+
+- **MCP Integration**
+  - McpClient for single server connections
+  - McpManager for multiple servers
+  - Trusted/untrusted server modes
+  - /mcp list and /mcp status commands
+
+- **Extension System**
+  - Extension base class
+  - Entry point discovery
+  - Local extension loading from ~/.henchman/extensions/
+  - /extensions list command
+
+- **Configuration**
+  - Hierarchical YAML settings
+  - Environment variable overrides
+  - HENCHMAN.md context file discovery
+  - Workspace and user-level settings
+
+- **Documentation**
+  - MkDocs site with Material theme
+  - Getting started guide
+  - Provider documentation
+  - Tool reference
+  - MCP integration guide
+  - Extension development guide
+  - API reference
+
+- **Quality**
+  - 100% test coverage (567+ tests)
+  - Type hints throughout
+  - Google-style docstrings
+  - Ruff linting and formatting
+  - Mypy type checking
+
+### Changed
+
+- Rebranded from mlg-cli to henchman-ai
+
+[Unreleased]: https://github.com/MGPowerlytics/henchman-ai/compare/v0.1.8...HEAD
+[0.1.8]: https://github.com/MGPowerlytics/henchman-ai/compare/v0.1.7...v0.1.8
+[0.1.7]: https://github.com/MGPowerlytics/henchman-ai/compare/v0.1.6...v0.1.7
+[0.1.6]: https://github.com/MGPowerlytics/henchman-ai/compare/v0.1.5...v0.1.6
+[0.1.5]: https://github.com/MGPowerlytics/henchman-ai/compare/v0.1.4...v0.1.5
+[0.1.4]: https://github.com/MGPowerlytics/henchman-ai/compare/v0.1.3...v0.1.4
+[0.1.3]: https://github.com/MGPowerlytics/henchman-ai/compare/v0.1.2...v0.1.3
+[0.1.2]: https://github.com/MGPowerlytics/henchman-ai/compare/v0.1.1...v0.1.2
+[0.1.1]: https://github.com/MGPowerlytics/henchman-ai/compare/v0.1.0...v0.1.1
+[0.1.0]: https://github.com/MGPowerlytics/henchman-ai/releases/tag/v0.1.0

{henchman_ai-0.1.7 → henchman_ai-0.1.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: henchman-ai
-Version: 0.1.7
+Version: 0.1.9
 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.9/PROJECT_PLAN.md

@@ -0,0 +1,233 @@
+# Henchman-AI Tool Usage Improvement Project Plan
+
+## Overview
+This document outlines a comprehensive plan to enhance the tool usage capabilities of the Henchman-AI agent system. The goal is to make tool interactions more efficient, intelligent, and user-friendly.
+
+## Current State Analysis
+The current tool system provides basic file operations, shell commands, and web fetching capabilities. Tools are invoked individually with stateless interactions and minimal error recovery.
+
+## Improvement Categories
+
+### 1. Error Handling & Recovery ✅
+**Goal**: Make tool usage more resilient to failures
+**Implementation Plan**:
+- Add automatic retry logic with exponential backoff ✅
+- Implement fallback strategies for common failure modes
+- Add detailed error diagnostics and suggestions
+- Create error recovery templates for different tool types
+
+**Status**: Implemented - Retry utilities with exponential backoff for NETWORK tools
+**Priority**: High
+**Estimated Effort**: 2-3 weeks
+
+### 2. Tool Chaining & Pipelining
+**Goal**: Enable seamless data flow between tools
+**Implementation Plan**:
+- Design a pipeline DSL for tool composition
+- Implement output/input type matching system
+- Create pipeline execution engine
+- Add pipeline visualization and debugging
+
+**Priority**: High
+**Estimated Effort**: 3-4 weeks
+
+### 3. Context-Aware Tool Selection
+**Goal**: Intelligent tool recommendation based on context
+**Implementation Plan**:
+- Build tool usage pattern analyzer
+- Implement file type detection and appropriate tool mapping
+- Create context-aware tool suggestion engine
+- Add learning from user preferences
+
+**Priority**: Medium
+**Estimated Effort**: 2-3 weeks
+
+### 4. Batch Operations ✅
+**Goal**: Support efficient bulk operations
+**Implementation Plan**:
+- Design batch operation API ✅
+- Implement parallel execution for independent operations ✅
+- Add progress tracking for batch jobs
+- Create batch operation templates
+
+**Status**: Implemented - execute_batch() with asyncio.gather() for parallel execution
+**Priority**: Medium
+**Estimated Effort**: 2 weeks
+
+### 5. Interactive Preview Mode
+**Goal**: Safe editing with preview capabilities
+**Implementation Plan**:
+- Implement diff generation for file changes
+- Create preview interface for tool outputs
+- Add confirmation workflows for destructive operations
+- Design undo/redo capability
+
+**Priority**: Medium
+**Estimated Effort**: 2-3 weeks
+
+### 6. State Management
+**Goal**: Maintain context across tool interactions
+**Implementation Plan**:
+- Design session state management system
+- Implement tool usage history tracking
+- Create context persistence across turns
+- Add state visualization and management tools
+
+**Priority**: Low
+**Estimated Effort**: 3 weeks
+
+### 7. Tool Composition
+**Goal**: Create higher-level tools from basic ones
+**Implementation Plan**:
+- Design tool composition language
+- Implement tool template system
+- Create tool library with common compositions
+- Add tool composition sharing mechanism
+
+**Priority**: Medium
+**Estimated Effort**: 3 weeks
+
+### 8. Progress Feedback
+**Goal**: Provide real-time feedback for long operations
+**Implementation Plan**:
+- Implement progress tracking framework
+- Create progress visualization components
+- Add estimated time remaining calculations
+- Design interruptible operations
+
+**Priority**: Low
+**Estimated Effort**: 2 weeks
+
+### 9. Resource Management
+**Goal**: Efficient handling of large resources
+**Implementation Plan**:
+- Implement streaming file processing
+- Add memory usage monitoring and limits
+- Create resource cleanup mechanisms
+- Design pagination for large outputs
+
+**Priority**: Medium
+**Estimated Effort**: 2 weeks
+
+### 10. Tool Validation & Safety
+**Goal**: Prevent errors through validation
+**Implementation Plan**:
+- Create comprehensive parameter validation system
+- Implement pre-execution safety checks
+- Add tool-specific validation rules
+- Design validation feedback system
+
+**Priority**: High
+**Estimated Effort**: 2 weeks
+
+### 11. Learning from Usage Patterns
+**Goal**: Adaptive tool behavior based on usage
+**Implementation Plan**:
+- Implement usage pattern collection
+- Create pattern analysis engine
+- Design adaptive tool suggestions
+- Add user preference learning
+
+**Priority**: Low
+**Estimated Effort**: 4 weeks
+
+### 12. Cross-Tool Optimization
+**Goal**: Optimize sequences of tool calls
+**Implementation Plan**:
+- Implement tool call caching system
+- Create dependency analysis for tool sequences
+- Design optimization rules engine
+- Add performance monitoring
+
+**Priority**: Low
+**Estimated Effort**: 3 weeks
+
+### 13. Better Documentation Integration
+**Goal**: Inline help and examples
+**Implementation Plan**:
+- Enhance tool documentation system
+- Create interactive help with examples
+- Implement context-sensitive documentation
+- Add tool tutorial system
+
+**Priority**: Medium
+**Estimated Effort**: 2 weeks
+
+### 14. Tool Discovery & Suggestions
+**Goal**: Help users find the right tools
+**Implementation Plan**:
+- Create tool discovery interface
+- Implement intent-based tool matching
+- Add tool recommendation engine
+- Design tool exploration features
+
+**Priority**: Medium
+**Estimated Effort**: 2 weeks
+
+### 15. Permission & Safety Controls
+**Goal**: Configurable security boundaries
+**Implementation Plan**:
+- Design permission system architecture
+- Implement tool access controls
+- Create safety confirmation workflows
+- Add audit logging for sensitive operations
+
+**Priority**: High
+**Estimated Effort**: 3 weeks
+
+## Implementation Phases
+
+### Phase 1: Foundation (Weeks 1-6)
+1. Error Handling & Recovery
+2. Tool Validation & Safety
+3. Permission & Safety Controls
+
+### Phase 2: Intelligence (Weeks 7-12)
+1. Context-Aware Tool Selection
+2. Tool Discovery & Suggestions
+3. Better Documentation Integration
+
+### Phase 3: Efficiency (Weeks 13-18)
+1. Tool Chaining & Pipelining
+2. Batch Operations
+3. Resource Management
+
+### Phase 4: User Experience (Weeks 19-24)
+1. Interactive Preview Mode
+2. Progress Feedback
+3. Tool Composition
+
+### Phase 5: Advanced Features (Weeks 25-30)
+1. State Management
+2. Learning from Usage Patterns
+3. Cross-Tool Optimization
+
+## Success Metrics
+- 50% reduction in tool usage errors
+- 30% improvement in task completion time
+- 40% increase in user satisfaction scores
+- 25% reduction in manual tool selection
+
+## Risks & Mitigations
+1. **Performance Overhead**: Monitor and optimize critical paths
+2. **Complexity Creep**: Maintain backward compatibility
+3. **Security Concerns**: Implement thorough security reviews
+4. **User Adoption**: Provide gradual migration paths
+
+## Dependencies
+- Current tool system architecture
+- User feedback and usage patterns
+- Available development resources
+
+## Next Steps
+1. Review current tool implementation code
+2. Create detailed design documents for Phase 1
+3. Set up development environment and testing infrastructure
+4. Begin implementation of error handling improvements
+
+## Conclusion
+This comprehensive improvement plan will transform Henchman-AI's tool usage from basic command execution to an intelligent, efficient, and user-friendly system. The phased approach ensures manageable development while delivering continuous value to users.
+
+Last Updated: $(date)
+Project Lead: [To be assigned]
+Status: Planning Phase