llm-tool-maker 0.1.0__tar.gz

llm_tool_maker-0.1.0/.env.example

@@ -0,0 +1,5 @@
+# Tool Maker — Database configuration
+# Copy to .env or ~/.config/tool-maker/.env
+
+# PostgreSQL connection string for the tool-maker store
+TOOLMAKER_DB_DSN=postgresql://user:password@localhost:5432/toolmaker

llm_tool_maker-0.1.0/.github/workflows/ci.yml

@@ -0,0 +1,51 @@
+name: CI
+
+on:
+  push:
+    branches: ["*"]
+  pull_request:
+    branches: ["*"]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.10", "3.11", "3.12", "3.13", "3.14"]
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: astral-sh/setup-uv@v5
+
+      - name: Set up Python ${{ matrix.python-version }}
+        run: uv python pin ${{ matrix.python-version }}
+
+      - name: Install dependencies
+        run: uv sync --group dev
+
+      - name: Ruff lint
+        run: uv run ruff check src/
+
+      - name: Run tests
+        run: uv run pytest
+
+  build:
+    runs-on: ubuntu-latest
+    needs: test
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: astral-sh/setup-uv@v5
+
+      - name: Set up Python
+        run: uv python pin 3.12
+
+      - name: Build package
+        run: uv build
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: dist
+          path: dist/

llm_tool_maker-0.1.0/.github/workflows/release.yml

@@ -0,0 +1,83 @@
+name: Release
+
+on:
+  push:
+    tags:
+      - "v*"
+  workflow_dispatch:
+    inputs:
+      version:
+        description: "Version to publish (e.g. 0.2.0)"
+        required: true
+
+permissions:
+  id-token: write
+  contents: write
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - uses: astral-sh/setup-uv@v5
+
+      - name: Set up Python
+        run: uv python pin 3.12
+
+      - name: Build package
+        run: uv build
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: dist
+          path: dist/
+
+  publish:
+    runs-on: ubuntu-latest
+    needs: build
+    environment: pypi
+
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          name: dist
+          path: dist/
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+
+  github-release:
+    runs-on: ubuntu-latest
+    needs: build
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - uses: actions/download-artifact@v4
+        with:
+          name: dist
+          path: dist/
+
+      - name: Generate changelog
+        id: changelog
+        run: |
+          echo "changelog<<EOF" >> $GITHUB_OUTPUT
+          git log --oneline "$(git tag --sort=-creatordate | head -1)..HEAD" 2>/dev/null \
+            || echo "Initial release"
+          echo "EOF" >> $GITHUB_OUTPUT
+
+      - name: Create Release
+        uses: softprops/action-gh-release@v2
+        with:
+          files: dist/*
+          body: |
+            ## tool-maker ${{ github.ref_name }}
+
+            ${{ steps.changelog.outputs.changelog }}
+          generate_release_notes: true

llm_tool_maker-0.1.0/.gitignore

@@ -0,0 +1,64 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual environments
+.venv/
+venv/
+ENV/
+env/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+*~
+
+# Testing
+.pytest_cache/
+.coverage
+htmlcov/
+.tox/
+
+# Linting
+.mypy_cache/
+.ruff_cache/
+
+# Generated files
+generated_tools/
+*.generated.py
+
+# Environment variables
+.env
+.env.local
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Documentation
+docs/_build/
+
+# Distribution
+dist/
+build/
+*.whl

llm_tool_maker-0.1.0/.python-version

@@ -0,0 +1 @@
+3.12

llm_tool_maker-0.1.0/DEVELOPMENT.md

@@ -0,0 +1,139 @@
+# Tool Maker - Development Setup
+
+## Prerequisites
+
+- Python 3.10 or higher
+- [uv](https://github.com/astral-sh/uv) package manager
+
+## Installation
+
+### 1. Clone the repository
+
+```bash
+git clone https://github.com/yourusername/tool_maker.git
+cd tool_maker
+```
+
+### 2. Set up the development environment with uv
+
+```bash
+# Initialize uv project (if not already done)
+uv init
+
+# Sync dependencies
+uv sync
+
+# Activate the virtual environment
+source .venv/bin/activate  # On Windows: .venv\Scripts\activate
+```
+
+### 3. Install development dependencies
+
+```bash
+uv add --dev pytest black ruff
+```
+
+## Development Commands
+
+### Running Tests
+
+```bash
+uv run pytest
+```
+
+### Running Linter
+
+```bash
+uv run ruff check .
+```
+
+### Formatting Code
+
+```bash
+uv run black .
+```
+
+### Running Type Checker
+
+```bash
+uv run mypy src/tool_maker
+```
+
+## Building the Package
+
+```bash
+# Build the package
+uv build
+
+# Install locally for testing
+uv pip install dist/tool_maker-*.whl
+```
+
+## Testing the CLI
+
+```bash
+# Run the CLI
+uv run tool-maker --help
+
+# Analyze a project
+uv run tool-maker analyze /path/to/project
+
+# Generate a tool
+uv run tool-maker generate "create a CSV parser" --project .
+```
+
+## Project Structure
+
+```
+tool_maker/
+├── src/
+│   └── tool_maker/          # Main package
+│       ├── analyzer/       # Project analysis
+│       ├── llm/           # LLM integration
+│       ├── tool/          # Tool generation
+│       ├── flask/         # Flask integration
+│       └── cli/           # CLI interface
+├── tests/                  # Test files
+├── examples/              # Usage examples
+├── pyproject.toml         # uv project configuration
+└── requirements.txt       # Python dependencies
+```
+
+## Adding New Features
+
+1. Create a new branch: `git checkout -b feature/your-feature`
+2. Implement your feature
+3. Add tests for your feature
+4. Run linting and tests: `uv run ruff check . && uv run pytest`
+5. Format code: `uv run black .`
+6. Commit and push: `git commit -m 'Add some feature' && git push origin feature/your-feature`
+
+## LLM Provider Setup
+
+### OpenAI
+
+```bash
+export OPENAI_API_KEY="sk-..."
+```
+
+### Anthropic (Claude)
+
+```bash
+export ANTHROPIC_API_KEY="sk-..."
+```
+
+## Documentation
+
+Generate documentation:
+
+```bash
+uv run pdoc --html --output-dir docs src/tool_maker
+```
+
+## Contributing
+
+1. Fork the repository
+2. Create a feature branch
+3. Make your changes
+4. Run tests and linting
+5. Submit a pull request

llm_tool_maker-0.1.0/IMPLEMENTATION_PLAN.md

@@ -0,0 +1,249 @@
+# Tool Maker - Implementation Plan
+
+## Overview
+This document outlines the implementation plan for the Tool Maker package - a Python package using `uv` that acts as an intelligent tool-making assistant leveraging LLMs.
+
+## Current Status
+✅ Project structure created
+✅ Core modules designed
+✅ pyproject.toml configured
+✅ README and documentation started
+
+## Implementation Tasks
+
+### Phase 1: Core Infrastructure (Priority: High)
+- [ ] Complete `__init__.py` with proper imports
+- [ ] Implement main `ToolMaker` class that orchestrates all components
+- [ ] Add proper error handling and logging
+- [ ] Create unit tests for core modules
+
+### Phase 2: Project Analyzer Enhancements (Priority: High)
+- [ ] Add support for more file types (JavaScript, TypeScript, etc.)
+- [ ] Implement dependency parsing for pyproject.toml and requirements.txt
+- [ ] Add module dependency graph generation
+- [ ] Create project profiling capabilities
+
+### Phase 3: LLM Integration (Priority: High)
+- [ ] Implement additional LLM providers (Ollama, local models)
+- [ ] Add conversation history management
+- [ ] Implement prompt templates and management
+- [ ] Add token usage tracking and limits
+- [ ] Create LLM provider abstraction layer
+
+### Phase 4: Tool Generation (Priority: High)
+- [ ] Implement more sophisticated tool templates
+- [ ] Add code generation using LLM
+- [ ] Create tool validation and testing
+- [ ] Implement tool versioning and management
+- [ ] Add tool documentation generation
+
+### Phase 5: Tool Execution (Priority: High)
+- [ ] Implement tool sandboxing for security
+- [ ] Add tool execution logging
+- [ ] Create tool result caching
+- [ ] Implement tool execution monitoring
+
+### Phase 6: Flask Integration (Priority: Medium)
+- [ ] Complete Flask extension implementation
+- [ ] Add API endpoints documentation
+- [ ] Create Flask example applications
+- [ ] Implement authentication and security
+
+### Phase 7: CLI Enhancements (Priority: Medium)
+- [ ] Add interactive mode
+- [ ] Implement configuration file support
+- [ ] Add progress indicators for long operations
+- [ ] Create configuration management
+
+### Phase 8: Testing & Documentation (Priority: High)
+- [ ] Write comprehensive unit tests
+- [ ] Create integration tests
+- [ ] Add example projects for testing
+- [ ] Write detailed documentation
+- [ ] Create video tutorials or demos
+
+### Phase 9: Package Distribution (Priority: Medium)
+- [ ] Set up CI/CD pipeline
+- [ ] Configure package publishing
+- [ ] Create setup scripts
+- [ ] Add auto-update capabilities
+
+## Technical Decisions
+
+### Package Management
+- **Tool**: `uv` for fast Python package management
+- **Build System**: `hatchling` for modern Python packaging
+- **Dependency Management**: `pyproject.toml` with uv
+
+### LLM Integration Strategy
+- **Abstract Interface**: Create a base `LLMProvider` class
+- **Multiple Providers**: Support OpenAI, Anthropic, and local models
+- **Configuration**: Environment variables and explicit configuration
+- **Fallback Mechanisms**: Graceful degradation if primary provider fails
+
+### Tool Generation Approach
+- **Template-based**: Use templates for common tool types
+- **LLM-assisted**: Use LLM for complex tool generation
+- **Hybrid**: Combine template and LLM generation
+- **Validation**: Validate generated tools before execution
+
+### Security Considerations
+- **Sandboxing**: Execute tools in isolated environments
+- **Input Validation**: Validate all user inputs
+- **Access Control**: Implement permission checks
+- **Audit Logging**: Log all tool executions
+
+## File Structure
+
+```
+tool_maker/
+├── src/
+│   └── tool_maker/
+│       ├── __init__.py              # Main package init
+│       ├── tool_maker.py            # Main ToolMaker class
+│       ├── analyzer/
+│       │   ├── __init__.py
+│       │   ├── project_scanner.py   # Project analysis
+│       │   └── dependency_parser.py # Dependency analysis
+│       ├── llm/
+│       │   ├── __init__.py
+│       │   ├── provider.py          # LLM providers
+│       │   ├── prompt_manager.py    # Prompt templates
+│       │   └── conversation.py      # Conversation history
+│       ├── tool/
+│       │   ├── __init__.py
+│       │   ├── generator.py         # Tool generation
+│       │   ├── executor.py          # Tool execution
+│       │   ├── validator.py         # Tool validation
+│       │   └── sandbox.py           # Tool sandboxing
+│       ├── flask/
+│       │   ├── __init__.py
+│       │   └── extension.py         # Flask extension
+│       └── cli/
+│           ├── __init__.py
+│           └── main.py              # CLI entry point
+├── tests/
+│   ├── __init__.py
+│   ├── test_analyzer.py
+│   ├── test_llm.py
+│   ├── test_tool_generation.py
+│   └── test_integration.py
+├── examples/
+│   ├── basic_usage.py
+│   ├── flask_integration.py
+│   └── custom_analyzer.py
+├── pyproject.toml
+├── requirements.txt
+├── README.md
+├── DEVELOPMENT.md
+└── PLAN.md                          # This file
+```
+
+## Dependencies
+
+### Core Dependencies
+- `requests` or `httpx` for HTTP requests
+- `pathlib` for file operations
+- `ast` for Python code analysis
+
+### Optional Dependencies
+- `openai` for OpenAI integration
+- `anthropic` for Claude integration
+- `flask` for Flask integration
+- `tomli` for TOML parsing (Python < 3.11)
+
+### Development Dependencies
+- `pytest` for testing
+- `black` for code formatting
+- `ruff` for linting
+- `mypy` for type checking
+
+## API Design
+
+### Main ToolMaker Class
+```python
+class ToolMaker:
+    def __init__(self, llm_provider: LLMProvider):
+        self.llm_provider = llm_provider
+        self.project_scanner = ProjectScanner()
+        self.tool_generator = ToolGenerator()
+        self.tool_executor = ToolExecutor()
+    
+    def analyze_project(self, project_path: str) -> Dict[str, Any]:
+        pass
+    
+    def create_tool(self, query: str, project_path: str = ".") -> Tool:
+        pass
+    
+    def execute_tool(self, tool: Tool, **kwargs) -> ToolResult:
+        pass
+    
+    def create_and_execute_tool(self, query: str, project_path: str = ".") -> ToolResult:
+        pass
+```
+
+### LLM Provider Interface
+```python
+class LLMProvider(ABC):
+    @abstractmethod
+    async def generate(self, prompt: str, **kwargs) -> str:
+        pass
+    
+    @abstractmethod
+    async def analyze_project(self, project_info: Dict[str, Any]) -> Dict[str, Any]:
+        pass
+```
+
+### Tool Class
+```python
+@dataclass
+class Tool:
+    name: str
+    description: str
+    parameters: Dict[str, Any]
+    code: str
+    module: str = "generated_tools"
+    function_name: str = ""
+    dependencies: List[str] = field(default_factory=list)
+```
+
+## Next Steps
+
+1. **Implement ToolMaker class** - Create the main orchestrator class
+2. **Add unit tests** - Test core functionality
+3. **Implement LLM provider** - Add OpenAI integration
+4. **Create example projects** - Test with real projects
+5. **Documentation** - Write comprehensive docs
+
+## Timeline Estimate
+
+- **Phase 1**: 2-3 days
+- **Phase 2**: 3-4 days
+- **Phase 3**: 4-5 days
+- **Phase 4**: 3-4 days
+- **Phase 5**: 2-3 days
+- **Phase 6**: 2-3 days
+- **Phase 7**: 1-2 days
+- **Phase 8**: 3-4 days
+- **Phase 9**: 2-3 days
+
+**Total**: ~20-30 days for a functional package
+
+## Success Criteria
+
+- [ ] Package can be installed with `uv add tool-maker`
+- [ ] Package can be used standalone or with Flask
+- [ ] Project analysis works for common Python projects
+- [ ] LLM integration supports at least one provider
+- [ ] Tool generation creates functional code
+- [ ] CLI interface works for basic operations
+- [ ] All tests pass
+- [ ] Documentation is complete
+
+## Notes
+
+- Keep the package lightweight and focused
+- Prioritize core functionality over features
+- Make it easy to extend with new LLM providers
+- Ensure security in tool execution
+- Provide clear examples for users