llm-tool-maker 0.1.0__py3-none-any.whl

llm_tool_maker-0.1.0.dist-info/METADATA

@@ -0,0 +1,199 @@
+Metadata-Version: 2.4
+Name: llm-tool-maker
+Version: 0.1.0
+Summary: An intelligent tool-making package that leverages LLMs to analyze projects and generate tools
+Project-URL: Homepage, https://github.com/codewithwest/project_tool-maker
+Project-URL: Repository, https://github.com/codewithwest/project_tool-maker
+Project-URL: Documentation, https://github.com/codewithwest/project_tool-maker#readme
+Project-URL: Issues, https://github.com/codewithwest/project_tool-maker/issues
+Author-email: west <westdynamics.tech@gmail.com>
+License: MIT
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Code Generators
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.24.0
+Requires-Dist: python-dotenv>=1.2.2
+Requires-Dist: requests>=2.31.0
+Requires-Dist: tomli>=2.0.0; python_version < '3.11'
+Provides-Extra: all
+Requires-Dist: flask>=2.3.0; extra == 'all'
+Requires-Dist: psycopg2-binary>=2.9.0; extra == 'all'
+Provides-Extra: flask
+Requires-Dist: flask>=2.3.0; extra == 'flask'
+Provides-Extra: postgres
+Requires-Dist: psycopg2-binary>=2.9.0; extra == 'postgres'
+Description-Content-Type: text/markdown
+
+# Tool Maker Package
+
+[![CI](https://github.com/codewithwest/project_tool-maker/actions/workflows/ci.yml/badge.svg)](https://github.com/codewithwest/project_tool-maker/actions/workflows/ci.yml)
+[![PyPI version](https://img.shields.io/pypi/v/llm-tool-maker.svg)](https://pypi.org/project/llm-tool-maker/)
+[![Python versions](https://img.shields.io/pypi/pyversions/llm-tool-maker.svg)](https://pypi.org/project/llm-tool-maker/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+An intelligent tool-making package that leverages LLMs to analyze projects and generate tools.
+
+## Overview
+
+Tool Maker is a Python package that:
+- Analyzes projects to understand their structure and capabilities
+- Uses LLMs to formulate intelligent prompts and generate tools
+- Can be integrated into Flask applications or used standalone
+- Provides a CLI for easy command-line usage
+
+## Features
+
+- **Project Analysis**: Automatically scans and analyzes project structure
+- **LLM Integration**: Supports multiple LLM providers (OpenAI, Anthropic, local models)
+- **Tool Generation**: Creates appropriate tools based on project capabilities
+- **Flask Integration**: Easy integration with Flask applications
+- **CLI Interface**: Command-line tool for quick usage
+
+## Installation
+
+### Using uv (Recommended)
+
+```bash
+# Install globally
+uv tool install llm-tool-maker
+
+# Or add to a project
+uv add llm-tool-maker
+```
+
+### From Source
+
+```bash
+git clone https://github.com/codewithwest/project_tool-maker.git
+cd tool-maker
+uv sync
+uv run tool-maker --help
+```
+
+## Quick Start
+
+### Standalone Usage
+
+```python
+from tool_maker import ToolMaker
+
+# Initialize with your LLM provider
+tm = ToolMaker(
+    llm_provider="openai",
+    api_key="your-api-key"
+)
+
+# Analyze a project
+project_info = tm.analyze_project("/path/to/project")
+
+# Create and execute a tool
+result = tm.create_and_execute_tool("Create a function to parse CSV files")
+print(result)
+```
+
+### Flask Integration
+
+```python
+from flask import Flask, request, jsonify
+from tool_maker.flask import ToolMakerExtension
+
+app = Flask(__name__)
+
+# Initialize Tool Maker
+tm = ToolMakerExtension(
+    app,
+    llm_provider="openai",
+    api_key="your-api-key"
+)
+
+@app.route('/analyze', methods=['POST'])
+def analyze():
+    project_path = request.json.get('project_path')
+    return jsonify(tm.analyze_project(project_path))
+
+@app.route('/tools', methods=['POST'])
+def create_tool():
+    query = request.json.get('query')
+    return jsonify(tm.create_and_execute_tool(query))
+```
+
+## Project Structure
+
+```
+tool_maker/
+├── analyzer/      # Project analysis module
+├── llm/          # LLM integration module
+├── tool/         # Tool generation and execution
+├── flask/        # Flask integration
+└── cli/          # Command-line interface
+```
+
+## Configuration
+
+### LLM Providers
+
+Tool Maker supports multiple LLM providers:
+
+```python
+# OpenAI
+tm = ToolMaker(llm_provider="openai", api_key="sk-...")
+
+# Anthropic (Claude)
+tm = ToolMaker(llm_provider="anthropic", api_key="sk-...")
+
+# Local LLM (e.g., Ollama)
+tm = ToolMaker(
+    llm_provider="ollama",
+    base_url="http://localhost:11434",
+    model="llama2"
+)
+```
+
+## Development
+
+```bash
+# Set up development environment
+uv sync
+uv run pytest
+
+# Run linter
+uv run ruff check .
+
+# Format code
+uv run black .
+```
+
+## Examples
+
+See the `examples/` directory for more detailed examples:
+- `basic_usage.py` - Standalone usage
+- `flask_integration.py` - Flask integration
+- `custom_analyzer.py` - Custom project analysis
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+1. Fork the repository
+2. Create a feature branch (`git checkout -b feature/amazing-feature`)
+3. Commit your changes (`git commit -m 'Add some amazing feature'`)
+4. Push to the branch (`git push origin feature/amazing-feature`)
+5. Open a Pull Request
+
+## License
+
+This project is licensed under the MIT License - see the LICENSE file for details.
+
+## Acknowledgments
+
+- Built with [uv](https://github.com/astral-sh/uv) for fast Python package management
+- Inspired by AI-powered code generation tools

llm_tool_maker-0.1.0.dist-info/RECORD

@@ -0,0 +1,48 @@
+tool_maker/__init__.py,sha256=Fu-PmlqhGH17lYK6_6FHS0uQ6ZcnZVYn1HLhNftLu7Q,792
+tool_maker/config.py,sha256=fLVdB0xp_tFmEurGKkQqMurFzEdyu_LeJo6w8TM6dSI,1504
+tool_maker/dotenv.py,sha256=oT4RFo30JhXma6sf0IiWgxFTjLuNYeipmLE0k7EMQtI,2009
+tool_maker/tool_fixer.py,sha256=U-Ekf1H-ckSZvzMhxaqAwoT2J5IBP9tnvX7T_h6Ftl0,4503
+tool_maker/tool_maker.py,sha256=5C5wUpJJlNrrRtElcxp9duJPbvhS1le3lIgRh7XlAG0,15660
+tool_maker/analyzer/__init__.py,sha256=fec7Oy7Dd4CjNhmFCBnGmtwij-0uh3ZJVn2Y6D32DmA,140
+tool_maker/analyzer/project_scanner.py,sha256=dTQL0Aa0QSmANMKJWt06uF-Lw60nKSyWYsirkXI2Jr4,7246
+tool_maker/cli/__init__.py,sha256=0FLqjwBp_1KGnsjyuixCA4q2VrZmHzX28TxeGOd2AB0,91
+tool_maker/cli/main.py,sha256=I_U2qc5OZ2xTz2uQTczrkNYaxoiJ7FcgcNoAdxE2h9o,10735
+tool_maker/db/__init__.py,sha256=UFrVdyPkqnVO3Xa2HpiHslQGsqngMwGO_hr05LN8HZM,356
+tool_maker/db/config.py,sha256=D8ITwvcyXqtOaOTc5ylGuvTD6lDJqVoGIiQX3vjHSqw,666
+tool_maker/db/connection.py,sha256=7qoZ3C8lOX379zLIGt3OHzH43FIBwgzgj9pciIajy0E,4769
+tool_maker/db/migrator.py,sha256=BtPjI0Orgh9RJtTilLdedEqxfxlF0upZb4aHPl6o4Ic,3392
+tool_maker/db/models.py,sha256=nrxOnL_2H3sz4G6yV7sm5Vdzb5hQ2OUcrdeRYqMXzYU,7979
+tool_maker/db/pipeline.py,sha256=aF3jeE2jrA0G88otDfnzjBnipUqPRZjodhgPkXtS1rg,18400
+tool_maker/db/migrations/001_initial.sql,sha256=Jqxh8SsrRyJl44xXye4svVYFC5t52mQTnwfP4cHduxk,1883
+tool_maker/flask/__init__.py,sha256=kLZQhh9FKTEeelmu8_3y3N_3lL4_jNB0hHuRwH71rcI,152
+tool_maker/flask/extension.py,sha256=oiW7GLHr1W-4aWywdFOLZGsSOKWDFApeh6d-tJ0WFvA,5254
+tool_maker/llm/__init__.py,sha256=_SynbkHqhcgixvxgEsAarOCjEjImG73bX-SLArnMT-s,133
+tool_maker/llm/provider.py,sha256=944shnSzZx1Sv1MvnLFjW9OFZ-aeWARqeDFpJiAIHzY,8182
+tool_maker/planner/__init__.py,sha256=Uy_SmYzRGcOo7B4uGOmcfgBR3TgUXuqO8OIiG4e5RfI,483
+tool_maker/planner/executor.py,sha256=_ec5v9Or5yUpK49kpUH4Tur6re85HKRgPoljpWfOJmc,2992
+tool_maker/planner/models.py,sha256=Glxf3sLqG-fhvaxplFP67s84veyiTiHzFrh_r5fuHF8,1354
+tool_maker/planner/planner.py,sha256=GTFD_JE5tniB21sm3Z60kL9qDuD1adKv5PeDeMxA4Z4,3726
+tool_maker/planner/reviewer.py,sha256=cxG_2tbz1FLwOGx2CI0NieO8R8uOOxENBr666wnkhDE,2357
+tool_maker/planner/validator.py,sha256=0qY_js8mNWLhd8HxwLQsFLW5A4rsR9CXoWwm7URP8NI,3446
+tool_maker/planner/writer.py,sha256=pgisuWufvX1qnpqx8atlA-EixJjIqj4hd2Bp7Ve7WlA,1011
+tool_maker/tool/__init__.py,sha256=OWVMRXdKKdOABkYdn6EPldQfwfA3mWt0q3XjsuVJ1Pc,317
+tool_maker/tool/executor.py,sha256=H6N6zziqqHpHq6_WXMOgfVEkIepml3jlJVVgtCiORAg,5411
+tool_maker/tool/generator.py,sha256=gIJvWNStEBszSVJpwe7mNtcIVvwUxjwP9mtetNbvtYU,6962
+tool_maker/tool/sandbox.py,sha256=-bMSPJTOxDK6Dqq_YUbIs8KBPNKTAbloahEPjA5BmgU,7070
+tool_maker/ui/__init__.py,sha256=Z-QaTL2IfyA4n8Wpy3-BVHz-wNQd_HQAFmVGQSyZXLE,113
+tool_maker/ui/app.py,sha256=IQOPk5iszjLWn2sOxA52lpAFUl1yCDhu53xq78Jgc6U,1756
+tool_maker/ui/log_handler.py,sha256=LJumsSBKNd-Lkk6vNxw5D6AWneggiImP9lN-Jp5IhTg,1813
+tool_maker/ui/routes.py,sha256=a4_qo9wmuaOzrBA6BHVDUhM29_g9f04WGe3lHR8Na-o,17390
+tool_maker/ui/static/style.css,sha256=a0vphjk0gEYC-DViGBXe7ZF3rqHyuUNqsoPSHhc7x4A,11637
+tool_maker/ui/templates/analyze.html,sha256=XjXv1H05Ib44eSQIyeSYOZ16NKVvgYKbxUXtLtnPujM,1613
+tool_maker/ui/templates/base.html,sha256=kDga9Drs-CfI3HNQOv-8H0-Zf0YYUi2t2yqINL4Idcw,881
+tool_maker/ui/templates/config.html,sha256=oa_gpIV8OxhIfUVY29FgRDohX3_yahkfxUMp02MZ8Hc,4138
+tool_maker/ui/templates/execute.html,sha256=5z63ImLnVgz53t4REU55BTR-n2XWGEoYzTX8kqb8-Z4,11101
+tool_maker/ui/templates/generate.html,sha256=Cg3JDwjZrNRbWEWSwuXGZDWfEmHm7uaer6YY1R4Jbks,1447
+tool_maker/ui/templates/index.html,sha256=97ziv9r3Xf6s74JFQBGthu88K6rKOEPTUrmxfzUZXDc,1901
+tool_maker/ui/templates/pipeline.html,sha256=Hjel9HShHN0MatiTyKnKV_HqTUXMa0FcUXWeS_HOEzY,13236
+tool_maker/ui/templates/provider.html,sha256=WxCJKpxV4AvNvNrCNQxLCLLUO487ZgHeJPp9_STAr4Q,1917
+llm_tool_maker-0.1.0.dist-info/METADATA,sha256=OuG5joYDEL_xRBEOJJtW1NWfeRTEfQ2g3eb0f4Ufp74,5768
+llm_tool_maker-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+llm_tool_maker-0.1.0.dist-info/entry_points.txt,sha256=J_34bQd3noKx-P4tmSB0K9ZMo-i5vN-thBukoqDwV90,60
+llm_tool_maker-0.1.0.dist-info/RECORD,,

llm_tool_maker-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any

llm_tool_maker-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+llm-tool-maker = tool_maker.cli.main:main

tool_maker/__init__.py

@@ -0,0 +1,31 @@
+"""
+Tool Maker - An intelligent tool-making package that leverages LLMs.
+"""
+
+__version__ = "0.1.0"
+__author__ = "Your Name"
+
+from tool_maker.analyzer.project_scanner import ProjectScanner
+from tool_maker.config import ToolMakerConfigFile
+from tool_maker.llm.provider import LLMProvider, get_provider
+from tool_maker.tool.generator import ToolGenerator
+from tool_maker.tool.executor import ToolExecutor
+from tool_maker.tool_fixer import ToolFixer
+from tool_maker.tool_maker import (
+    ToolMaker,
+    create_tool_maker,
+    create_tool_maker_from_env,
+)
+
+__all__ = [
+    "ProjectScanner",
+    "LLMProvider",
+    "get_provider",
+    "ToolGenerator",
+    "ToolExecutor",
+    "ToolFixer",
+    "ToolMakerConfigFile",
+    "ToolMaker",
+    "create_tool_maker",
+    "create_tool_maker_from_env",
+]

tool_maker/analyzer/__init__.py

@@ -0,0 +1,7 @@
+"""
+Project Analyzer - Scans and analyzes project structure.
+"""
+
+from .project_scanner import ProjectScanner
+
+__all__ = ["ProjectScanner"]

tool_maker/analyzer/project_scanner.py

@@ -0,0 +1,202 @@
+"""
+Project Scanner - Scans and analyzes project structure.
+"""
+
+import ast
+from pathlib import Path
+from typing import Dict, List, Any, Optional
+import json
+
+
+class ProjectScanner:
+    """Scans and analyzes project structure to understand capabilities."""
+
+    def __init__(self, project_path: str):
+        self.project_path = Path(project_path)
+        self.modules: List[Dict[str, Any]] = []
+        self.dependencies: List[str] = []
+        self.entry_points: List[str] = []
+        self.project_info: Dict[str, Any] = {}
+
+    def scan(self) -> Dict[str, Any]:
+        """Scan the project and return analysis results."""
+        self._scan_modules()
+        self._scan_dependencies()
+        self._scan_entry_points()
+        self._analyze_project()
+
+        return self.project_info
+
+    def _scan_modules(self) -> None:
+        """Scan Python modules in the project."""
+        for py_file in self.project_path.rglob("*.py"):
+            if self._should_skip_file(py_file):
+                continue
+
+            try:
+                with open(py_file, 'r', encoding='utf-8') as f:
+                    content = f.read()
+
+                module_info = {
+                    "path": str(py_file.relative_to(self.project_path)),
+                    "name": self._get_module_name(py_file),
+                    "functions": [],
+                    "classes": [],
+                    "imports": []
+                }
+
+                try:
+                    tree = ast.parse(content)
+                    module_info = self._parse_ast(tree, module_info)
+                except SyntaxError:
+                    pass
+
+                self.modules.append(module_info)
+            except Exception:
+                # Skip files that can't be read or parsed
+                continue
+
+    def _parse_ast(self, tree: ast.AST, module_info: Dict[str, Any]) -> Dict[str, Any]:
+        """Parse AST to extract functions, classes, and imports."""
+        for node in ast.iter_child_nodes(tree):
+            if isinstance(node, ast.FunctionDef):
+                module_info["functions"].append({
+                    "name": node.name,
+                    "line": node.lineno,
+                    "docstring": ast.get_docstring(node)
+                })
+            elif isinstance(node, ast.ClassDef):
+                module_info["classes"].append({
+                    "name": node.name,
+                    "line": node.lineno,
+                    "docstring": ast.get_docstring(node)
+                })
+            elif isinstance(node, ast.Import):
+                for alias in node.names:
+                    module_info["imports"].append(alias.name)
+            elif isinstance(node, ast.ImportFrom):
+                if node.module:
+                    for alias in node.names:
+                        module_info["imports"].append(f"{node.module}.{alias.name}")
+
+        return module_info
+
+    def _should_skip_file(self, file_path: Path) -> bool:
+        """Determine if a file should be skipped during scanning."""
+        skip_patterns = [
+            "__pycache__",
+            ".venv",
+            "venv",
+            ".git",
+            ".env",
+            "node_modules",
+            ".mypy_cache",
+            ".pytest_cache",
+            "dist",
+            "build"
+        ]
+
+        return any(pattern in str(file_path) for pattern in skip_patterns)
+
+    def _get_module_name(self, file_path: Path) -> str:
+        """Get the module name from a file path."""
+        parts = []
+        for part in file_path.relative_to(self.project_path).parts:
+            if part == "__init__.py":
+                continue
+            parts.append(part.replace(".py", ""))
+
+        return ".".join(parts)
+
+    def _scan_dependencies(self) -> None:
+        """Scan for project dependencies."""
+        # Check for pyproject.toml
+        pyproject_path = self.project_path / "pyproject.toml"
+        if pyproject_path.exists():
+            try:
+                import tomli
+                with open(pyproject_path, 'rb') as f:
+                    data = tomli.load(f)
+
+                if "project" in data and "dependencies" in data["project"]:
+                    self.dependencies = data["project"]["dependencies"]
+            except ImportError:
+                # Try basic parsing if tomli is not available
+                pass
+
+        # Check for requirements.txt
+        requirements_path = self.project_path / "requirements.txt"
+        if requirements_path.exists():
+            with open(requirements_path, 'r') as f:
+                self.dependencies = [
+                    line.strip() for line in f
+                    if line.strip() and not line.startswith("#")
+                ]
+
+    def _scan_entry_points(self) -> None:
+        """Scan for entry points (main files, Flask apps, etc.)."""
+        # Look for common entry point patterns
+        entry_point_patterns = [
+            "main.py",
+            "app.py",
+            "wsgi.py",
+            "run.py",
+            "server.py"
+        ]
+
+        for pattern in entry_point_patterns:
+            entry_path = self.project_path / pattern
+            if entry_path.exists():
+                self.entry_points.append(str(entry_path.relative_to(self.project_path)))
+
+    def _analyze_project(self) -> None:
+        """Analyze the project and create a summary."""
+        self.project_info = {
+            "path": str(self.project_path),
+            "name": self.project_path.name,
+            "modules_count": len(self.modules),
+            "total_functions": sum(len(m["functions"]) for m in self.modules),
+            "total_classes": sum(len(m["classes"]) for m in self.modules),
+            "dependencies": self.dependencies,
+            "entry_points": self.entry_points,
+            "modules": self.modules,
+            "summary": self._generate_summary()
+        }
+
+    def _generate_summary(self) -> str:
+        """Generate a summary of the project."""
+        if not self.modules:
+            return "No Python modules found."
+
+        summary_parts = [
+            f"Project '{self.project_path.name}' contains {len(self.modules)} modules",
+            f"with {sum(len(m['functions']) for m in self.modules)} functions and "
+            f"{sum(len(m['classes']) for m in self.modules)} classes."
+        ]
+
+        if self.dependencies:
+            summary_parts.append(f"Has {len(self.dependencies)} dependencies.")
+
+        if self.entry_points:
+            summary_parts.append(f"Entry points: {', '.join(self.entry_points)}.")
+
+        return " ".join(summary_parts)
+
+    def get_module_by_name(self, name: str) -> Optional[Dict[str, Any]]:
+        """Get a module by its name."""
+        for module in self.modules:
+            if module["name"] == name:
+                return module
+        return None
+
+    def get_functions_by_module(self, module_name: str) -> List[Dict[str, Any]]:
+        """Get all functions in a specific module."""
+        module = self.get_module_by_name(module_name)
+        if module:
+            return module["functions"]
+        return []
+
+    def save_analysis(self, output_path: str) -> None:
+        """Save the analysis to a JSON file."""
+        with open(output_path, 'w') as f:
+            json.dump(self.project_info, f, indent=2)

tool_maker/cli/__init__.py

@@ -0,0 +1,7 @@
+"""
+Command-line interface for Tool Maker.
+"""
+
+from .main import main
+
+__all__ = ["main"]