# Mutator Framework
A comprehensive Python framework for building AI-powered coding agents that can execute complex coding tasks using Large Language Models (LLMs).
## Features
### Core Capabilities
- **LLM Integration**: Support for multiple LLM providers via LiteLLM (OpenAI, Anthropic, Google, etc.)
- **LangChain-Powered Execution**: Built on LangChain for robust agent orchestration, tool calling, and streaming
- **Intelligent Task Planning**: Simplified planning system where the LLM decides when to break down complex tasks
- **Extensible Tool System**: Modern @tool decorator for easy tool creation with built-in file operations, shell commands, and Git integration
- **Context Management**: Vector-based project context with ChromaDB for intelligent code understanding
- **Dual Execution Modes**: Chat mode (read-only) and Agent mode (full code modification)
- **Safety Features**: Configurable safety checks and user confirmations
- **Sub-Agent Delegation**: Automatic delegation of complex tasks to specialized sub-agents
- **Streaming Support**: Real-time streaming of agent responses and tool execution via LangGraph
### Advanced Features
- **MCP Server Integration**: Support for Model Context Protocol servers
- **Configuration Management**: Flexible configuration system with validation
- **Event-Driven Architecture**: Real-time execution monitoring and control
- **CLI Interface**: Rich command-line interface with interactive features
- **Extensible Design**: Easy to add custom tools and integrations
- **Tool Management**: Disable built-in tools to avoid conflicts with custom implementations
## Installation
```bash
pip install CodeMutator
```
### Development Installation
```bash
git clone https://github.com/code-mutator/mutator.git
cd mutator
pip install -e .
```
## Quick Start
### Basic Usage
```python
import asyncio
from mutator import Mutator, AgentConfig, ExecutionMode
async def main():
# Create and initialize agent
config = AgentConfig(working_directory="./my_project")
agent = Mutator(config)
await agent.initialize()
# Execute a simple task
async for event in agent.execute_task(
"Add error handling to the main.py file",
execution_mode=ExecutionMode.AGENT
):
print(f"{event.event_type}: {event.data}")
asyncio.run(main())
```
### Chat Mode
```python
import asyncio
from mutator import Mutator, AgentConfig
async def main():
config = AgentConfig(working_directory="./my_project")
agent = Mutator(config)
await agent.initialize()
# Chat without making changes
response = await agent.chat("What does the main function do?")
print(response.content)
asyncio.run(main())
```
### CLI Usage
```bash
# Execute a task
mutator execute "Add unit tests for the authentication module" --project ./my_project
# Interactive chat
mutator chat --project ./my_project
# Single chat message
mutator chat "Explain the database schema" --project ./my_project
# Check agent status
mutator status --project ./my_project
# List available tools
mutator tools
```
## Configuration
### API Key Setup
The framework supports multiple LLM providers. Set up your API keys using environment variables:
```bash
# OpenAI
export OPENAI_API_KEY="your-openai-api-key"
# Anthropic
export ANTHROPIC_API_KEY="your-anthropic-api-key"
# Google
export GOOGLE_API_KEY="your-google-api-key"
# Azure OpenAI
export AZURE_API_KEY="your-azure-api-key"
export AZURE_API_BASE="https://your-resource.openai.azure.com/"
export AZURE_API_VERSION="2023-05-15"
```
### Provider Usage
```bash
# Use OpenAI (default)
mutator chat --model gpt-4-turbo-preview
# Use Anthropic Claude
mutator chat --provider anthropic --model claude-3-sonnet-20240229
# Use Google Gemini
mutator chat --provider google --model gemini-pro
# Use Azure OpenAI
mutator chat --provider azure --model gpt-4
```
### Creating Configuration
```bash
# Create default configuration
mutator config create --output my_config.json
# Validate configuration
mutator config validate my_config.json
# Show configuration
mutator config show my_config.json
```
### Configuration Structure
```json
{
"llm_config": {
"model": "gpt-4-turbo-preview",
"provider": "openai",
"api_key": "your-api-key",
"max_tokens": 2000,
"temperature": 0.1
},
"context_config": {
"project_path": "./",
"max_context_files": 20,
"ignore_patterns": ["*.pyc", "__pycache__", ".git"]
},
"safety_config": {
"confirmation_level": "medium",
"allowed_shell_commands": ["ls", "cat", "git"],
"blocked_shell_commands": ["rm", "sudo", "wget"]
},
"execution_config": {
"default_mode": "agent",
"max_iterations": 50,
"retry_on_failure": true
},
"disabled_tools": [
"git_status",
"git_add",
"run_shell"
]
}
```
### Provider-Specific Configuration Examples
#### OpenAI Configuration
```json
{
"llm_config": {
"provider": "openai",
"model": "gpt-4-turbo-preview",
"api_key": "your-openai-api-key",
"max_tokens": 4000,
"temperature": 0.1
}
}
```
#### Anthropic Configuration
```json
{
"llm_config": {
"provider": "anthropic",
"model": "claude-3-sonnet-20240229",
"api_key": "your-anthropic-api-key",
"max_tokens": 4000,
"temperature": 0.1
}
}
```
#### Google Configuration
```json
{
"llm_config": {
"provider": "google",
"model": "gemini-pro",
"api_key": "your-google-api-key",
"max_tokens": 2048,
"temperature": 0.1
}
}
```
#### Azure OpenAI Configuration
```json
{
"llm_config": {
"provider": "azure",
"model": "gpt-4",
"api_key": "your-azure-api-key",
"base_url": "https://your-resource.openai.azure.com/",
"api_version": "2023-05-15",
"max_tokens": 4000,
"temperature": 0.1
}
}
```
## Examples
### Complex Task Execution
```python
import asyncio
from mutator import Mutator, AgentConfig, ExecutionMode
async def refactor_codebase():
config = AgentConfig(working_directory="./my_project")
agent = Mutator(config)
await agent.initialize()
task = """
Refactor the user authentication system:
1. Extract authentication logic into a separate service
2. Add comprehensive error handling
3. Implement rate limiting
4. Add unit tests for all new components
5. Update documentation
"""
async for event in agent.execute_task(
task,
execution_mode=ExecutionMode.AGENT
):
if event.event_type == "task_started":
print(f"Starting: {event.data}")
elif event.event_type == "tool_call_completed":
print(f"Completed: {event.data['tool_name']}")
elif event.event_type == "task_completed":
print("Task completed successfully!")
asyncio.run(refactor_codebase())
```
### Custom Tool Creation (Modern @tool Decorator)
```python
from mutator import Mutator, AgentConfig
from mutator.tools.decorator import tool
@tool
def calculate_complexity(file_path: str) -> dict:
"""Calculate code complexity metrics for a file."""
try:
with open(file_path, 'r') as f:
content = f.read()
lines = len(content.splitlines())
functions = content.count('def ')
classes = content.count('class ')
return {
"file_path": file_path,
"lines_of_code": lines,
"functions": functions,
"classes": classes,
"complexity_score": lines + functions * 2 + classes * 3
}
except Exception as e:
return {"error": f"Failed to analyze file: {str(e)}"}
@tool
def format_json(data: str, indent: int = 2) -> dict:
"""Format JSON data with proper indentation."""
try:
import json
parsed = json.loads(data)
formatted = json.dumps(parsed, indent=indent)
return {
"formatted_json": formatted,
"original_length": len(data),
"formatted_length": len(formatted)
}
except Exception as e:
return {"error": f"Invalid JSON: {str(e)}"}
async def main():
# Create agent
config = AgentConfig()
agent = Mutator(config)
await agent.initialize()
# Register custom tools
agent.tool_manager.register_function(calculate_complexity)
agent.tool_manager.register_function(format_json)
# Use the tools
result = await agent.tool_manager.execute_tool("calculate_complexity", {"file_path": "main.py"})
print(f"Complexity analysis: {result}")
# Or let the LLM use them in tasks
async for event in agent.execute_task(
"Analyze the complexity of all Python files in the src directory and format the results as JSON"
):
print(f"{event.event_type}: {event.data}")
asyncio.run(main())
```
### Project Analysis
```python
import asyncio
from mutator import Mutator, AgentConfig
async def analyze_project():
config = AgentConfig(working_directory="./my_project")
agent = Mutator(config)
await agent.initialize()
# Get project context
context = await agent.context_manager.get_project_context()
print(f"Project: {context.get('project_name', 'Unknown')}")
print(f"Files: {len(context.get('files', []))}")
# Search for specific patterns
results = await agent.context_manager.search_context("authentication", max_results=5)
for result in results:
print(f"Found in {result['file_path']}: {result['content'][:100]}...")
asyncio.run(analyze_project())
```
### Configuration Management
```python
import asyncio
from mutator import AgentConfig, LLMConfig, SafetyConfig
from mutator.core.types import ConfirmationLevel
async def custom_configuration():
# Create custom configuration
config = AgentConfig(
llm_config=LLMConfig(
model="claude-3-sonnet-20240229",
max_tokens=4000,
temperature=0.2
),
safety_config=SafetyConfig(
confirmation_level=ConfirmationLevel.HIGH,
allowed_shell_commands=["git", "ls", "cat"],
blocked_shell_commands=["rm", "sudo", "curl"]
),
disabled_tools=["web_search", "fetch_url"] # Disable web tools
)
# Create agent with custom config
agent = Mutator(config)
await agent.initialize()
# Execute task with custom settings
async for event in agent.execute_task(
"Review the codebase and suggest improvements"
):
print(f"{event.event_type}: {event.data}")
asyncio.run(custom_configuration())
```
## Architecture
### Core Components
1. **Mutator**: Main orchestrator class
2. **LLMClient**: Interface to language models
3. **ToolManager**: Tool registration and execution with @tool decorator support
4. **ContextManager**: Project understanding and vector search
5. **TaskPlanner**: Simplified task analysis and prompt creation
6. **TaskExecutor**: Task execution with LLM-driven tool selection
### Execution Flow
```
Task Input → Complexity Analysis → LLM Execution → Tool Selection → Sub-Agent Delegation (if needed) → Results
```
### Modern Tool System
The framework uses a modern `@tool` decorator system:
```python
from mutator.tools.decorator import tool
@tool
def my_tool(param1: str, param2: int = 10) -> dict:
"""Tool description here."""
# Tool implementation
return {"result": "success"}
```
Features:
- **Automatic schema generation** from function signatures
- **Type inference** from annotations
- **Default parameter handling**
- **Async support** for both sync and async functions
- **Error handling** with structured responses
### Safety Features
- **Confirmation Levels**: None, Low, Medium, High
- **Command Filtering**: Allowed/blocked shell commands
- **Path Validation**: Prevent dangerous file operations
- **Interactive Mode**: User confirmation for tool execution
- **Tool Disabling**: Disable specific tools to prevent conflicts
## Advanced Usage
### Sub-Agent Task Delegation
The framework includes a powerful `task` tool that automatically delegates complex operations to sub-agents:
```python
# The LLM will automatically use the task tool for complex operations
async for event in agent.execute_task(
"Implement a complete REST API with authentication, rate limiting, and comprehensive tests"
):
if event.event_type == "tool_call_started" and event.data.get("tool_name") == "task":
print("Delegating to sub-agent for complex task execution")
```
### Event Monitoring
```python
async def monitor_execution():
config = AgentConfig()
agent = Mutator(config)
await agent.initialize()
async for event in agent.execute_task("Create a new API endpoint"):
if event.event_type == "tool_call_started":
print(f"Executing: {event.data['tool_name']}")
elif event.event_type == "complexity_analysis":
print(f"Task complexity: {event.data['recommended_type']}")
elif event.event_type == "task_failed":
print(f"Task failed: {event.data['error']}")
break
```
### Context Management
```python
# Custom context configuration
from mutator.core.config import ContextConfig
context_config = ContextConfig(
project_path="./my_project",
max_context_files=50,
ignore_patterns=["*.pyc", "__pycache__", ".git", "node_modules"],
file_size_limit=1024 * 1024 # 1MB
)
config = AgentConfig(context_config=context_config)
agent = Mutator(config)
```
### Disabled Tools
You can disable specific built-in tools to avoid conflicts with custom implementations:
```python
from mutator import Mutator, AgentConfig
# Disable git tools when using GitHub API
config = AgentConfig(
disabled_tools=[
"git_status",
"git_add",
"git_commit",
"git_log"
]
)
agent = Mutator(config)
await agent.initialize()
# Git tools are now disabled, use your custom GitHub API tools instead
```
Common use cases:
- **GitHub API Integration**: Disable git tools to use GitHub API instead
- **Security**: Disable shell tools in restricted environments
- **Performance**: Disable unused tools to reduce overhead
## CLI Reference
### Main Commands
```bash
# Execute tasks
mutator execute "task description" [options]
# Chat with agent
mutator chat [message] [options]
# Check status
mutator status [options]
# List tools
mutator tools [options]
# Configuration management
mutator config create [options]
mutator config validate <config-file>
mutator config show <config-file>
```
### Options
```bash
--project, -p Path to project directory
--config, -c Path to configuration file
--mode, -m Execution mode (chat/agent)
--type, -t Task type (simple/complex)
--verbose, -v Verbose output
--interactive, -i Interactive mode with confirmations
```
### Examples
```bash
# Execute with custom config
mutator execute "Add logging to all functions" --config my_config.json --project ./src
# Interactive chat session
mutator chat --project ./my_app
# Single chat message
mutator chat "What's the purpose of the main.py file?" --project ./my_app
# Check agent status
mutator status --project ./my_app
# List available tools
mutator tools --config my_config.json
# Create configuration
mutator config create --output ./configs/dev_config.json
# Validate configuration
mutator config validate ./configs/dev_config.json
```
## Best Practices
### Task Design
- **Be Specific**: Clear, actionable task descriptions
- **Let the LLM Decide**: The framework automatically determines when to use sub-agents
- **Provide Context**: Include relevant project information
### Tool Development
- **Use @tool Decorator**: Leverage the modern tool system for easy development
- **Type Annotations**: Use type hints for automatic schema generation
- **Error Handling**: Return structured error responses
- **Documentation**: Include clear docstrings for tool descriptions
### Safety
- **Use Confirmation Levels**: Appropriate safety for your environment
- **Limit Shell Commands**: Restrict dangerous operations
- **Review Generated Code**: Always review before deploying
- **Disable Unused Tools**: Reduce attack surface by disabling unnecessary tools
### Performance
- **Optimize Context**: Limit context size for faster processing
- **Use Appropriate Models**: Balance capability with cost
- **Monitor Resource Usage**: Track API calls and processing time
- **Disable Unused Tools**: Reduce initialization overhead
## Contributing
We welcome contributions to the Mutator Framework! Please follow these guidelines to ensure a smooth development experience.
### Development Setup
#### Prerequisites
- Python 3.8+ (Python 3.11+ recommended for Apple Silicon Macs)
- Git
#### Quick Setup
1. **Fork and Clone the Repository**
```bash
git clone https://github.com/code-mutator/mutator.git
cd mutator
```
2. **Create Virtual Environment**
```bash
# Create virtual environment
python -m venv .venv
# Activate virtual environment
# On macOS/Linux:
source .venv/bin/activate
# On Windows:
.venv\Scripts\activate
```
3. **Install Dependencies**
```bash
# Upgrade pip
pip install --upgrade pip
# Install project in development mode with dev dependencies
pip install -e ".[dev]"
```
4. **Verify Installation**
```bash
# Test CLI
mutator --help
# Run tests
pytest tests/
```
#### Apple Silicon (ARM64) Setup
If you're on Apple Silicon (M1/M2/M3 Mac) and encounter architecture compatibility issues:
1. **Use Virtual Environment (Recommended)**
```bash
# Create and activate virtual environment
python -m venv .venv
source .venv/bin/activate
# Install with ARM64 compatibility
pip install --upgrade pip
pip install -e .
```
2. **Alternative: Use Homebrew Python**
```bash
# Install Homebrew Python (if not already installed)
brew install python@3.11
# Create virtual environment with Homebrew Python
/opt/homebrew/bin/python3.11 -m venv .venv
source .venv/bin/activate
# Install dependencies
pip install -e .
```
3. **Verify Architecture**
```bash
python -c "import platform; print(f'Architecture: {platform.machine()}')"
# Should output: arm64
```
#### Development Workflow
1. **Create Feature Branch**
```bash
git checkout -b feature/your-feature-name
```
2. **Make Changes**
- Follow the existing code style and patterns
- Add type hints where appropriate
- Include docstrings for new functions/classes
3. **Run Tests**
```bash
# Run all tests
pytest tests/
# Run specific test file
pytest tests/unit/test_tools.py
# Run with coverage
pytest tests/ --cov=mutator
```
4. **Code Quality Checks**
```bash
# Format code (if black is installed)
black mutator/ tests/
# Sort imports (if isort is installed)
isort mutator/ tests/
# Type checking (if mypy is installed)
mypy mutator/
```
5. **Test CLI Functionality**
```bash
# Test with virtual environment
source .venv/bin/activate
mutator status
mutator tools
# Or use the wrapper script
./run_mutator.sh status
./run_mutator.sh tools
```
#### Adding New Tools
When adding new tools, use the modern `@tool` decorator:
```python
from mutator.tools.decorator import tool
from typing import Optional
@tool
def my_new_tool(
required_param: str,
optional_param: Optional[int] = None
) -> dict:
"""
Brief description of what the tool does.
Args:
required_param: Description of required parameter
optional_param: Description of optional parameter
Returns:
Dictionary with results or error information
"""
try:
# Tool implementation
result = f"Processed {required_param}"
return {
"success": True,
"result": result,
"optional_used": optional_param is not None
}
except Exception as e:
return {
"success": False,
"error": str(e)
}
```
#### Testing Guidelines
1. **Unit Tests**: Test individual functions and classes
2. **Integration Tests**: Test tool interactions and workflows
3. **CLI Tests**: Test command-line interface functionality
4. **Architecture Tests**: Ensure compatibility across platforms
Example test structure:
```python
import pytest
from mutator.tools.your_tool import your_function
def test_your_function_success():
"""Test successful execution of your function."""
result = your_function("test_input")
assert result["success"] is True
assert "result" in result
def test_your_function_error_handling():
"""Test error handling in your function."""
result = your_function(None) # Should cause error
assert result["success"] is False
assert "error" in result
```
#### Troubleshooting Development Issues
**Architecture Errors on Apple Silicon:**
```bash
# If you see "mach-o file, but is an incompatible architecture" errors:
# 1. Delete existing virtual environment
rm -rf .venv
# 2. Create new virtual environment
python -m venv .venv
source .venv/bin/activate
# 3. Reinstall with no cache
pip install --no-cache-dir -e .
```
**Import Errors:**
```bash
# Make sure virtual environment is activated
source .venv/bin/activate
# Reinstall in development mode
pip install -e .
```
**CLI Not Working:**
```bash
# Use the wrapper script
./run_mutator.sh --help
# Or activate virtual environment first
source .venv/bin/activate
mutator --help
```
#### Submitting Changes
1. **Commit Changes**
```bash
git add .
git commit -m "feat: add new tool for X functionality"
```
2. **Push to Fork**
```bash
git push origin feature/your-feature-name
```
3. **Create Pull Request**
- Include clear description of changes
- Reference any related issues
- Include tests for new functionality
- Update documentation if needed
#### Commit Message Format
Use conventional commit format:
- `feat:` - New features
- `fix:` - Bug fixes
- `docs:` - Documentation changes
- `test:` - Test additions/changes
- `refactor:` - Code refactoring
- `chore:` - Maintenance tasks
Examples:
```
feat: add web scraping tool with rate limiting
fix: resolve architecture compatibility on Apple Silicon
docs: update contribution guidelines with venv setup
test: add integration tests for tool manager
```
### Development Environment Verification
After setup, verify everything works:
```bash
# 1. Activate virtual environment
source .venv/bin/activate
# 2. Check CLI
mutator --help
mutator status
# 3. Run tests
pytest tests/ -v
# 4. Test tool functionality
python -c "
from mutator import Mutator, AgentConfig
import asyncio
async def test():
config = AgentConfig()
agent = Mutator(config)
await agent.initialize()
tools = await agent.tool_manager.list_tools()
print(f'Available tools: {len(tools)}')
asyncio.run(test())
"
```
If all steps complete successfully, you're ready to contribute!
## License
see LICENSE file for details.
Raw data
{
"_id": null,
"home_page": null,
"name": "CodeMutator",
"maintainer": null,
"docs_url": null,
"requires_python": ">=3.8",
"maintainer_email": null,
"keywords": "mutator, agent, ai, llm, framework, python, development, automation",
"author": null,
"author_email": "Mutator SDK Team <info@codemutator.com>",
"download_url": "https://files.pythonhosted.org/packages/3c/be/9439612963aef6d8ce3b0d94264b18c7c0f82dbf09455d9ab1183bb1bd74/codemutator-0.0.10.tar.gz",
"platform": null,
"description": "# Mutator Framework\n\nA comprehensive Python framework for building AI-powered coding agents that can execute complex coding tasks using Large Language Models (LLMs).\n\n## Features\n\n### Core Capabilities\n- **LLM Integration**: Support for multiple LLM providers via LiteLLM (OpenAI, Anthropic, Google, etc.)\n- **LangChain-Powered Execution**: Built on LangChain for robust agent orchestration, tool calling, and streaming\n- **Intelligent Task Planning**: Simplified planning system where the LLM decides when to break down complex tasks\n- **Extensible Tool System**: Modern @tool decorator for easy tool creation with built-in file operations, shell commands, and Git integration\n- **Context Management**: Vector-based project context with ChromaDB for intelligent code understanding\n- **Dual Execution Modes**: Chat mode (read-only) and Agent mode (full code modification)\n- **Safety Features**: Configurable safety checks and user confirmations\n- **Sub-Agent Delegation**: Automatic delegation of complex tasks to specialized sub-agents\n- **Streaming Support**: Real-time streaming of agent responses and tool execution via LangGraph\n\n### Advanced Features\n- **MCP Server Integration**: Support for Model Context Protocol servers\n- **Configuration Management**: Flexible configuration system with validation\n- **Event-Driven Architecture**: Real-time execution monitoring and control\n- **CLI Interface**: Rich command-line interface with interactive features\n- **Extensible Design**: Easy to add custom tools and integrations\n- **Tool Management**: Disable built-in tools to avoid conflicts with custom implementations\n\n\n## Installation\n\n```bash\npip install CodeMutator\n```\n\n### Development Installation\n\n```bash\ngit clone https://github.com/code-mutator/mutator.git\ncd mutator\npip install -e .\n```\n\n## Quick Start\n\n### Basic Usage\n\n```python\nimport asyncio\nfrom mutator import Mutator, AgentConfig, ExecutionMode\n\nasync def main():\n # Create and initialize agent\n config = AgentConfig(working_directory=\"./my_project\")\n agent = Mutator(config)\n await agent.initialize()\n \n # Execute a simple task\n async for event in agent.execute_task(\n \"Add error handling to the main.py file\",\n execution_mode=ExecutionMode.AGENT\n ):\n print(f\"{event.event_type}: {event.data}\")\n\nasyncio.run(main())\n```\n\n### Chat Mode\n\n```python\nimport asyncio\nfrom mutator import Mutator, AgentConfig\n\nasync def main():\n config = AgentConfig(working_directory=\"./my_project\")\n agent = Mutator(config)\n await agent.initialize()\n \n # Chat without making changes\n response = await agent.chat(\"What does the main function do?\")\n print(response.content)\n\nasyncio.run(main())\n```\n\n### CLI Usage\n\n```bash\n# Execute a task\nmutator execute \"Add unit tests for the authentication module\" --project ./my_project\n\n# Interactive chat\nmutator chat --project ./my_project\n\n# Single chat message\nmutator chat \"Explain the database schema\" --project ./my_project\n\n# Check agent status\nmutator status --project ./my_project\n\n# List available tools\nmutator tools\n```\n\n## Configuration\n\n### API Key Setup\n\nThe framework supports multiple LLM providers. Set up your API keys using environment variables:\n\n```bash\n# OpenAI\nexport OPENAI_API_KEY=\"your-openai-api-key\"\n\n# Anthropic\nexport ANTHROPIC_API_KEY=\"your-anthropic-api-key\"\n\n# Google\nexport GOOGLE_API_KEY=\"your-google-api-key\"\n\n# Azure OpenAI\nexport AZURE_API_KEY=\"your-azure-api-key\"\nexport AZURE_API_BASE=\"https://your-resource.openai.azure.com/\"\nexport AZURE_API_VERSION=\"2023-05-15\"\n```\n\n### Provider Usage\n\n```bash\n# Use OpenAI (default)\nmutator chat --model gpt-4-turbo-preview\n\n# Use Anthropic Claude\nmutator chat --provider anthropic --model claude-3-sonnet-20240229\n\n# Use Google Gemini\nmutator chat --provider google --model gemini-pro\n\n# Use Azure OpenAI\nmutator chat --provider azure --model gpt-4\n```\n\n### Creating Configuration\n\n```bash\n# Create default configuration\nmutator config create --output my_config.json\n\n# Validate configuration\nmutator config validate my_config.json\n\n# Show configuration\nmutator config show my_config.json\n```\n\n### Configuration Structure\n\n```json\n{\n \"llm_config\": {\n \"model\": \"gpt-4-turbo-preview\",\n \"provider\": \"openai\",\n \"api_key\": \"your-api-key\",\n \"max_tokens\": 2000,\n \"temperature\": 0.1\n },\n \"context_config\": {\n \"project_path\": \"./\",\n \"max_context_files\": 20,\n \"ignore_patterns\": [\"*.pyc\", \"__pycache__\", \".git\"]\n },\n \"safety_config\": {\n \"confirmation_level\": \"medium\",\n \"allowed_shell_commands\": [\"ls\", \"cat\", \"git\"],\n \"blocked_shell_commands\": [\"rm\", \"sudo\", \"wget\"]\n },\n \"execution_config\": {\n \"default_mode\": \"agent\",\n \"max_iterations\": 50,\n \"retry_on_failure\": true\n },\n \"disabled_tools\": [\n \"git_status\",\n \"git_add\",\n \"run_shell\"\n ]\n}\n```\n\n### Provider-Specific Configuration Examples\n\n#### OpenAI Configuration\n```json\n{\n \"llm_config\": {\n \"provider\": \"openai\",\n \"model\": \"gpt-4-turbo-preview\",\n \"api_key\": \"your-openai-api-key\",\n \"max_tokens\": 4000,\n \"temperature\": 0.1\n }\n}\n```\n\n#### Anthropic Configuration\n```json\n{\n \"llm_config\": {\n \"provider\": \"anthropic\",\n \"model\": \"claude-3-sonnet-20240229\",\n \"api_key\": \"your-anthropic-api-key\",\n \"max_tokens\": 4000,\n \"temperature\": 0.1\n }\n}\n```\n\n#### Google Configuration\n```json\n{\n \"llm_config\": {\n \"provider\": \"google\",\n \"model\": \"gemini-pro\",\n \"api_key\": \"your-google-api-key\",\n \"max_tokens\": 2048,\n \"temperature\": 0.1\n }\n}\n```\n\n#### Azure OpenAI Configuration\n```json\n{\n \"llm_config\": {\n \"provider\": \"azure\",\n \"model\": \"gpt-4\",\n \"api_key\": \"your-azure-api-key\",\n \"base_url\": \"https://your-resource.openai.azure.com/\",\n \"api_version\": \"2023-05-15\",\n \"max_tokens\": 4000,\n \"temperature\": 0.1\n }\n}\n```\n\n## Examples\n\n### Complex Task Execution\n\n```python\nimport asyncio\nfrom mutator import Mutator, AgentConfig, ExecutionMode\n\nasync def refactor_codebase():\n config = AgentConfig(working_directory=\"./my_project\")\n agent = Mutator(config)\n await agent.initialize()\n \n task = \"\"\"\n Refactor the user authentication system:\n 1. Extract authentication logic into a separate service\n 2. Add comprehensive error handling\n 3. Implement rate limiting\n 4. Add unit tests for all new components\n 5. Update documentation\n \"\"\"\n \n async for event in agent.execute_task(\n task, \n execution_mode=ExecutionMode.AGENT\n ):\n if event.event_type == \"task_started\":\n print(f\"Starting: {event.data}\")\n elif event.event_type == \"tool_call_completed\":\n print(f\"Completed: {event.data['tool_name']}\")\n elif event.event_type == \"task_completed\":\n print(\"Task completed successfully!\")\n\nasyncio.run(refactor_codebase())\n```\n\n### Custom Tool Creation (Modern @tool Decorator)\n\n```python\nfrom mutator import Mutator, AgentConfig\nfrom mutator.tools.decorator import tool\n\n@tool\ndef calculate_complexity(file_path: str) -> dict:\n \"\"\"Calculate code complexity metrics for a file.\"\"\"\n try:\n with open(file_path, 'r') as f:\n content = f.read()\n \n lines = len(content.splitlines())\n functions = content.count('def ')\n classes = content.count('class ')\n \n return {\n \"file_path\": file_path,\n \"lines_of_code\": lines,\n \"functions\": functions,\n \"classes\": classes,\n \"complexity_score\": lines + functions * 2 + classes * 3\n }\n except Exception as e:\n return {\"error\": f\"Failed to analyze file: {str(e)}\"}\n\n@tool\ndef format_json(data: str, indent: int = 2) -> dict:\n \"\"\"Format JSON data with proper indentation.\"\"\"\n try:\n import json\n parsed = json.loads(data)\n formatted = json.dumps(parsed, indent=indent)\n return {\n \"formatted_json\": formatted,\n \"original_length\": len(data),\n \"formatted_length\": len(formatted)\n }\n except Exception as e:\n return {\"error\": f\"Invalid JSON: {str(e)}\"}\n\nasync def main():\n # Create agent\n config = AgentConfig()\n agent = Mutator(config)\n await agent.initialize()\n \n # Register custom tools\n agent.tool_manager.register_function(calculate_complexity)\n agent.tool_manager.register_function(format_json)\n \n # Use the tools\n result = await agent.tool_manager.execute_tool(\"calculate_complexity\", {\"file_path\": \"main.py\"})\n print(f\"Complexity analysis: {result}\")\n \n # Or let the LLM use them in tasks\n async for event in agent.execute_task(\n \"Analyze the complexity of all Python files in the src directory and format the results as JSON\"\n ):\n print(f\"{event.event_type}: {event.data}\")\n\nasyncio.run(main())\n```\n\n### Project Analysis\n\n```python\nimport asyncio\nfrom mutator import Mutator, AgentConfig\n\nasync def analyze_project():\n config = AgentConfig(working_directory=\"./my_project\")\n agent = Mutator(config)\n await agent.initialize()\n \n # Get project context\n context = await agent.context_manager.get_project_context()\n print(f\"Project: {context.get('project_name', 'Unknown')}\")\n print(f\"Files: {len(context.get('files', []))}\")\n \n # Search for specific patterns\n results = await agent.context_manager.search_context(\"authentication\", max_results=5)\n for result in results:\n print(f\"Found in {result['file_path']}: {result['content'][:100]}...\")\n\nasyncio.run(analyze_project())\n```\n\n### Configuration Management\n\n```python\nimport asyncio\nfrom mutator import AgentConfig, LLMConfig, SafetyConfig\nfrom mutator.core.types import ConfirmationLevel\n\nasync def custom_configuration():\n # Create custom configuration\n config = AgentConfig(\n llm_config=LLMConfig(\n model=\"claude-3-sonnet-20240229\",\n max_tokens=4000,\n temperature=0.2\n ),\n safety_config=SafetyConfig(\n confirmation_level=ConfirmationLevel.HIGH,\n allowed_shell_commands=[\"git\", \"ls\", \"cat\"],\n blocked_shell_commands=[\"rm\", \"sudo\", \"curl\"]\n ),\n disabled_tools=[\"web_search\", \"fetch_url\"] # Disable web tools\n )\n \n # Create agent with custom config\n agent = Mutator(config)\n await agent.initialize()\n \n # Execute task with custom settings\n async for event in agent.execute_task(\n \"Review the codebase and suggest improvements\"\n ):\n print(f\"{event.event_type}: {event.data}\")\n\nasyncio.run(custom_configuration())\n```\n\n## Architecture\n\n### Core Components\n\n1. **Mutator**: Main orchestrator class\n2. **LLMClient**: Interface to language models\n3. **ToolManager**: Tool registration and execution with @tool decorator support\n4. **ContextManager**: Project understanding and vector search\n5. **TaskPlanner**: Simplified task analysis and prompt creation\n6. **TaskExecutor**: Task execution with LLM-driven tool selection\n\n### Execution Flow\n\n```\nTask Input \u2192 Complexity Analysis \u2192 LLM Execution \u2192 Tool Selection \u2192 Sub-Agent Delegation (if needed) \u2192 Results\n```\n\n### Modern Tool System\n\nThe framework uses a modern `@tool` decorator system:\n\n```python\nfrom mutator.tools.decorator import tool\n\n@tool\ndef my_tool(param1: str, param2: int = 10) -> dict:\n \"\"\"Tool description here.\"\"\"\n # Tool implementation\n return {\"result\": \"success\"}\n```\n\nFeatures:\n- **Automatic schema generation** from function signatures\n- **Type inference** from annotations\n- **Default parameter handling**\n- **Async support** for both sync and async functions\n- **Error handling** with structured responses\n\n### Safety Features\n\n- **Confirmation Levels**: None, Low, Medium, High\n- **Command Filtering**: Allowed/blocked shell commands\n- **Path Validation**: Prevent dangerous file operations\n- **Interactive Mode**: User confirmation for tool execution\n- **Tool Disabling**: Disable specific tools to prevent conflicts\n\n## Advanced Usage\n\n### Sub-Agent Task Delegation\n\nThe framework includes a powerful `task` tool that automatically delegates complex operations to sub-agents:\n\n```python\n# The LLM will automatically use the task tool for complex operations\nasync for event in agent.execute_task(\n \"Implement a complete REST API with authentication, rate limiting, and comprehensive tests\"\n):\n if event.event_type == \"tool_call_started\" and event.data.get(\"tool_name\") == \"task\":\n print(\"Delegating to sub-agent for complex task execution\")\n```\n\n### Event Monitoring\n\n```python\nasync def monitor_execution():\n config = AgentConfig()\n agent = Mutator(config)\n await agent.initialize()\n \n async for event in agent.execute_task(\"Create a new API endpoint\"):\n if event.event_type == \"tool_call_started\":\n print(f\"Executing: {event.data['tool_name']}\")\n elif event.event_type == \"complexity_analysis\":\n print(f\"Task complexity: {event.data['recommended_type']}\")\n elif event.event_type == \"task_failed\":\n print(f\"Task failed: {event.data['error']}\")\n break\n```\n\n### Context Management\n\n```python\n# Custom context configuration\nfrom mutator.core.config import ContextConfig\n\ncontext_config = ContextConfig(\n project_path=\"./my_project\",\n max_context_files=50,\n ignore_patterns=[\"*.pyc\", \"__pycache__\", \".git\", \"node_modules\"],\n file_size_limit=1024 * 1024 # 1MB\n)\n\nconfig = AgentConfig(context_config=context_config)\nagent = Mutator(config)\n```\n\n### Disabled Tools\n\nYou can disable specific built-in tools to avoid conflicts with custom implementations:\n\n```python\nfrom mutator import Mutator, AgentConfig\n\n# Disable git tools when using GitHub API\nconfig = AgentConfig(\n disabled_tools=[\n \"git_status\",\n \"git_add\", \n \"git_commit\",\n \"git_log\"\n ]\n)\n\nagent = Mutator(config)\nawait agent.initialize()\n\n# Git tools are now disabled, use your custom GitHub API tools instead\n```\n\nCommon use cases:\n- **GitHub API Integration**: Disable git tools to use GitHub API instead\n- **Security**: Disable shell tools in restricted environments\n- **Performance**: Disable unused tools to reduce overhead\n\n## CLI Reference\n\n### Main Commands\n\n```bash\n# Execute tasks\nmutator execute \"task description\" [options]\n\n# Chat with agent\nmutator chat [message] [options]\n\n# Check status\nmutator status [options]\n\n# List tools\nmutator tools [options]\n\n# Configuration management\nmutator config create [options]\nmutator config validate <config-file>\nmutator config show <config-file>\n```\n\n### Options\n\n```bash\n--project, -p Path to project directory\n--config, -c Path to configuration file\n--mode, -m Execution mode (chat/agent)\n--type, -t Task type (simple/complex)\n--verbose, -v Verbose output\n--interactive, -i Interactive mode with confirmations\n```\n\n### Examples\n\n```bash\n# Execute with custom config\nmutator execute \"Add logging to all functions\" --config my_config.json --project ./src\n\n# Interactive chat session\nmutator chat --project ./my_app\n\n# Single chat message\nmutator chat \"What's the purpose of the main.py file?\" --project ./my_app\n\n# Check agent status\nmutator status --project ./my_app\n\n# List available tools\nmutator tools --config my_config.json\n\n# Create configuration\nmutator config create --output ./configs/dev_config.json\n\n# Validate configuration\nmutator config validate ./configs/dev_config.json\n```\n\n## Best Practices\n\n### Task Design\n- **Be Specific**: Clear, actionable task descriptions\n- **Let the LLM Decide**: The framework automatically determines when to use sub-agents\n- **Provide Context**: Include relevant project information\n\n### Tool Development\n- **Use @tool Decorator**: Leverage the modern tool system for easy development\n- **Type Annotations**: Use type hints for automatic schema generation\n- **Error Handling**: Return structured error responses\n- **Documentation**: Include clear docstrings for tool descriptions\n\n### Safety\n- **Use Confirmation Levels**: Appropriate safety for your environment\n- **Limit Shell Commands**: Restrict dangerous operations\n- **Review Generated Code**: Always review before deploying\n- **Disable Unused Tools**: Reduce attack surface by disabling unnecessary tools\n\n### Performance\n- **Optimize Context**: Limit context size for faster processing\n- **Use Appropriate Models**: Balance capability with cost\n- **Monitor Resource Usage**: Track API calls and processing time\n- **Disable Unused Tools**: Reduce initialization overhead\n\n## Contributing\n\nWe welcome contributions to the Mutator Framework! Please follow these guidelines to ensure a smooth development experience.\n\n### Development Setup\n\n#### Prerequisites\n- Python 3.8+ (Python 3.11+ recommended for Apple Silicon Macs)\n- Git\n\n#### Quick Setup\n\n1. **Fork and Clone the Repository**\n ```bash\n git clone https://github.com/code-mutator/mutator.git\n cd mutator\n ```\n\n2. **Create Virtual Environment**\n ```bash\n # Create virtual environment\n python -m venv .venv\n \n # Activate virtual environment\n # On macOS/Linux:\n source .venv/bin/activate\n # On Windows:\n .venv\\Scripts\\activate\n ```\n\n3. **Install Dependencies**\n ```bash\n # Upgrade pip\n pip install --upgrade pip\n \n # Install project in development mode with dev dependencies\n pip install -e \".[dev]\"\n ```\n\n4. **Verify Installation**\n ```bash\n # Test CLI\n mutator --help\n \n # Run tests\n pytest tests/\n ```\n\n#### Apple Silicon (ARM64) Setup\n\nIf you're on Apple Silicon (M1/M2/M3 Mac) and encounter architecture compatibility issues:\n\n1. **Use Virtual Environment (Recommended)**\n ```bash\n # Create and activate virtual environment\n python -m venv .venv\n source .venv/bin/activate\n \n # Install with ARM64 compatibility\n pip install --upgrade pip\n pip install -e .\n ```\n\n2. **Alternative: Use Homebrew Python**\n ```bash\n # Install Homebrew Python (if not already installed)\n brew install python@3.11\n \n # Create virtual environment with Homebrew Python\n /opt/homebrew/bin/python3.11 -m venv .venv\n source .venv/bin/activate\n \n # Install dependencies\n pip install -e .\n ```\n\n3. **Verify Architecture**\n ```bash\n python -c \"import platform; print(f'Architecture: {platform.machine()}')\"\n # Should output: arm64\n ```\n\n#### Development Workflow\n\n1. **Create Feature Branch**\n ```bash\n git checkout -b feature/your-feature-name\n ```\n\n2. **Make Changes**\n - Follow the existing code style and patterns\n - Add type hints where appropriate\n - Include docstrings for new functions/classes\n\n3. **Run Tests**\n ```bash\n # Run all tests\n pytest tests/\n \n # Run specific test file\n pytest tests/unit/test_tools.py\n \n # Run with coverage\n pytest tests/ --cov=mutator\n ```\n\n4. **Code Quality Checks**\n ```bash\n # Format code (if black is installed)\n black mutator/ tests/\n \n # Sort imports (if isort is installed)\n isort mutator/ tests/\n \n # Type checking (if mypy is installed)\n mypy mutator/\n ```\n\n5. **Test CLI Functionality**\n ```bash\n # Test with virtual environment\n source .venv/bin/activate\n mutator status\n mutator tools\n \n # Or use the wrapper script\n ./run_mutator.sh status\n ./run_mutator.sh tools\n ```\n\n#### Adding New Tools\n\nWhen adding new tools, use the modern `@tool` decorator:\n\n```python\nfrom mutator.tools.decorator import tool\nfrom typing import Optional\n\n@tool\ndef my_new_tool(\n required_param: str,\n optional_param: Optional[int] = None\n) -> dict:\n \"\"\"\n Brief description of what the tool does.\n \n Args:\n required_param: Description of required parameter\n optional_param: Description of optional parameter\n \n Returns:\n Dictionary with results or error information\n \"\"\"\n try:\n # Tool implementation\n result = f\"Processed {required_param}\"\n return {\n \"success\": True,\n \"result\": result,\n \"optional_used\": optional_param is not None\n }\n except Exception as e:\n return {\n \"success\": False,\n \"error\": str(e)\n }\n```\n\n#### Testing Guidelines\n\n1. **Unit Tests**: Test individual functions and classes\n2. **Integration Tests**: Test tool interactions and workflows\n3. **CLI Tests**: Test command-line interface functionality\n4. **Architecture Tests**: Ensure compatibility across platforms\n\nExample test structure:\n```python\nimport pytest\nfrom mutator.tools.your_tool import your_function\n\ndef test_your_function_success():\n \"\"\"Test successful execution of your function.\"\"\"\n result = your_function(\"test_input\")\n assert result[\"success\"] is True\n assert \"result\" in result\n\ndef test_your_function_error_handling():\n \"\"\"Test error handling in your function.\"\"\"\n result = your_function(None) # Should cause error\n assert result[\"success\"] is False\n assert \"error\" in result\n```\n\n#### Troubleshooting Development Issues\n\n**Architecture Errors on Apple Silicon:**\n```bash\n# If you see \"mach-o file, but is an incompatible architecture\" errors:\n# 1. Delete existing virtual environment\nrm -rf .venv\n\n# 2. Create new virtual environment\npython -m venv .venv\nsource .venv/bin/activate\n\n# 3. Reinstall with no cache\npip install --no-cache-dir -e .\n```\n\n**Import Errors:**\n```bash\n# Make sure virtual environment is activated\nsource .venv/bin/activate\n\n# Reinstall in development mode\npip install -e .\n```\n\n**CLI Not Working:**\n```bash\n# Use the wrapper script\n./run_mutator.sh --help\n\n# Or activate virtual environment first\nsource .venv/bin/activate\nmutator --help\n```\n\n#### Submitting Changes\n\n1. **Commit Changes**\n ```bash\n git add .\n git commit -m \"feat: add new tool for X functionality\"\n ```\n\n2. **Push to Fork**\n ```bash\n git push origin feature/your-feature-name\n ```\n\n3. **Create Pull Request**\n - Include clear description of changes\n - Reference any related issues\n - Include tests for new functionality\n - Update documentation if needed\n\n#### Commit Message Format\n\nUse conventional commit format:\n- `feat:` - New features\n- `fix:` - Bug fixes\n- `docs:` - Documentation changes\n- `test:` - Test additions/changes\n- `refactor:` - Code refactoring\n- `chore:` - Maintenance tasks\n\nExamples:\n```\nfeat: add web scraping tool with rate limiting\nfix: resolve architecture compatibility on Apple Silicon\ndocs: update contribution guidelines with venv setup\ntest: add integration tests for tool manager\n```\n\n### Development Environment Verification\n\nAfter setup, verify everything works:\n\n```bash\n# 1. Activate virtual environment\nsource .venv/bin/activate\n\n# 2. Check CLI\nmutator --help\nmutator status\n\n# 3. Run tests\npytest tests/ -v\n\n# 4. Test tool functionality\npython -c \"\nfrom mutator import Mutator, AgentConfig\nimport asyncio\n\nasync def test():\n config = AgentConfig()\n agent = Mutator(config)\n await agent.initialize()\n tools = await agent.tool_manager.list_tools()\n print(f'Available tools: {len(tools)}')\n\nasyncio.run(test())\n\"\n```\n\nIf all steps complete successfully, you're ready to contribute!\n\n## License\nsee LICENSE file for details.\n",
"bugtrack_url": null,
"license": "Apache-2.0",
"summary": "A comprehensive Python framework for building coding agents using GenAI",
"version": "0.0.10",
"project_urls": {
"Bug Reports": "https://github.com/code-mutator/mutator/issues",
"Documentation": "https://codemutator.readthedocs.io/",
"Homepage": "https://github.com/code-mutator/mutator",
"Repository": "https://github.com/code-mutator/mutator"
},
"split_keywords": [
"mutator",
" agent",
" ai",
" llm",
" framework",
" python",
" development",
" automation"
],
"urls": [
{
"comment_text": null,
"digests": {
"blake2b_256": "361393d456087fb73928e9f3570d0d274fe6672732ec2c97331da0eafa9a52d9",
"md5": "078a50be54287f944bdac88364966924",
"sha256": "1b86f02ac36ddb44f703a0d3f9a05bfbf9fd5b9c0257f0dd090d344e318c4bb3"
},
"downloads": -1,
"filename": "codemutator-0.0.10-py3-none-any.whl",
"has_sig": false,
"md5_digest": "078a50be54287f944bdac88364966924",
"packagetype": "bdist_wheel",
"python_version": "py3",
"requires_python": ">=3.8",
"size": 141029,
"upload_time": "2025-07-23T07:44:01",
"upload_time_iso_8601": "2025-07-23T07:44:01.044028Z",
"url": "https://files.pythonhosted.org/packages/36/13/93d456087fb73928e9f3570d0d274fe6672732ec2c97331da0eafa9a52d9/codemutator-0.0.10-py3-none-any.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": null,
"digests": {
"blake2b_256": "3cbe9439612963aef6d8ce3b0d94264b18c7c0f82dbf09455d9ab1183bb1bd74",
"md5": "ab4d9af53374818c0f1deeb5cc6682d9",
"sha256": "57003062c291f3cac08f63410ccfd8330ae9ea90d72f85975da6d1a2962ce564"
},
"downloads": -1,
"filename": "codemutator-0.0.10.tar.gz",
"has_sig": false,
"md5_digest": "ab4d9af53374818c0f1deeb5cc6682d9",
"packagetype": "sdist",
"python_version": "source",
"requires_python": ">=3.8",
"size": 157891,
"upload_time": "2025-07-23T07:44:02",
"upload_time_iso_8601": "2025-07-23T07:44:02.292734Z",
"url": "https://files.pythonhosted.org/packages/3c/be/9439612963aef6d8ce3b0d94264b18c7c0f82dbf09455d9ab1183bb1bd74/codemutator-0.0.10.tar.gz",
"yanked": false,
"yanked_reason": null
}
],
"upload_time": "2025-07-23 07:44:02",
"github": true,
"gitlab": false,
"bitbucket": false,
"codeberg": false,
"github_user": "code-mutator",
"github_project": "mutator",
"travis_ci": false,
"coveralls": false,
"github_actions": true,
"requirements": [
{
"name": "litellm",
"specs": [
[
">=",
"1.35.0"
]
]
},
{
"name": "pydantic",
"specs": [
[
">=",
"2.5.0"
]
]
},
{
"name": "pydantic-settings",
"specs": [
[
">=",
"2.1.0"
]
]
},
{
"name": "typing-extensions",
"specs": [
[
">=",
"4.8.0"
]
]
},
{
"name": "langchain",
"specs": [
[
">=",
"0.1.0"
],
[
"<",
"0.2.0"
]
]
},
{
"name": "langchain-core",
"specs": [
[
">=",
"0.1.0"
],
[
"<",
"0.2.0"
]
]
},
{
"name": "langgraph",
"specs": [
[
"<",
"0.1.0"
],
[
">=",
"0.0.50"
]
]
},
{
"name": "langchain-community",
"specs": [
[
"<",
"0.1.0"
],
[
">=",
"0.0.20"
]
]
},
{
"name": "chromadb",
"specs": [
[
">=",
"0.4.15"
]
]
},
{
"name": "sentence-transformers",
"specs": [
[
">=",
"2.2.2"
]
]
},
{
"name": "numpy",
"specs": [
[
">=",
"1.24.0"
]
]
},
{
"name": "typer",
"specs": [
[
">=",
"0.9.0"
]
]
},
{
"name": "rich",
"specs": [
[
">=",
"13.0.0"
]
]
},
{
"name": "prompt-toolkit",
"specs": [
[
">=",
"3.0.0"
]
]
},
{
"name": "pytest",
"specs": [
[
">=",
"7.4.0"
]
]
},
{
"name": "pytest-asyncio",
"specs": [
[
">=",
"0.21.0"
]
]
},
{
"name": "pathspec",
"specs": [
[
">=",
"0.11.0"
]
]
},
{
"name": "gitpython",
"specs": [
[
">=",
"3.1.40"
]
]
},
{
"name": "watchdog",
"specs": [
[
">=",
"3.0.0"
]
]
},
{
"name": "chardet",
"specs": [
[
">=",
"5.2.0"
]
]
},
{
"name": "httpx",
"specs": [
[
">=",
"0.24.0"
]
]
},
{
"name": "requests",
"specs": [
[
">=",
"2.31.0"
]
]
},
{
"name": "html2text",
"specs": [
[
">=",
"2020.1.16"
]
]
},
{
"name": "openai",
"specs": [
[
">=",
"1.3.0"
]
]
},
{
"name": "anthropic",
"specs": [
[
">=",
"0.7.0"
]
]
}
],
"lcname": "codemutator"
}
JSON
