scriptmonkey 0.1.1__tar.gz → 1.0.0__tar.gz

scriptmonkey-1.0.0/PKG-INFO

@@ -0,0 +1,141 @@
+Metadata-Version: 2.1
+Name: scriptmonkey
+Version: 1.0.0
+Summary: A Python package that generates complex Python projects and fixes errors in your code using OpenAI's GPT API.
+Home-page: https://github.com/lukerbs/ScriptMonkey
+Author: Luke Kerbs
+Author-email: LDK.kerbs@gmail.com
+License: MIT
+Keywords: openai,GPT,AI,project generation,multi-file project,complex project generator,code error fixing,code automation,GPT API,error correction,code assistant,AI coding tools,script monkey,automation,development tools,python tools,code analysis,machine learning,project bootstrap,custom code generation,python package
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+Requires-Dist: openai
+Requires-Dist: pydantic
+Requires-Dist: tqdm
+Requires-Dist: python-dotenv
+
+
+# ScriptMonkey 🐒
+
+ScriptMonkey is an AI-powered Python package that reimagines how projects are built. It doesn’t just generate simple scripts or templates like traditional LLMs—it creates **entire, multi-file, multi-directory projects with fully custom code**. Complex Python projects can be generated in seconds based on your natural language descriptions, providing everything you need, from models and routes to templates and configuration files. With ScriptMonkey, you can instantly bootstrap new ideas or start complex projects without the tedious setup. And with built-in error detection and automatic fixes, ScriptMonkey keeps your development process smooth and stress-free, letting you focus on what matters most: building.
+
+## Features
+- **Custom Project Generation**: Create entire Python projects, not just boilerplate code. ScriptMonkey generates the specific files and directories you need based on your description.
+- **Lightning-Fast Setup**: Complex Python projects can be generated in seconds, saving you time and effort.
+- **Automatic Error Detection**: Captures errors during runtime.
+- **AI-Powered Fixes**: Uses OpenAI's GPT API to understand and resolve errors.
+- **Code Auto-Correction**: Automatically updates your Python files with the fixes.
+- **Cross-IDE Compatibility**: Works with any IDE or code editor.
+
+## Installation
+
+To install ScriptMonkey, simply run:
+
+```bash
+pip install scriptmonkey
+```
+
+## Usage
+
+### Project Generation with `python3 -m scriptmonkey`
+
+ScriptMonkey can generate a complete, custom-coded project structure based on a description you provide. This feature helps you quickly set up new projects with the necessary files and folders.
+
+#### How to Use
+
+1. Run the following command in your terminal:
+
+   ```bash
+   python3 -m scriptmonkey
+   ```
+
+2. A text editor will open (e.g., `nano`, `vim`, or `notepad` depending on your environment). Follow the on-screen instructions to provide a detailed description of your project.
+
+3. Save and close the editor. ScriptMonkey will then:
+   - Generate a complete project structure based on your description.
+   - Create directories, code files, and templates.
+   - Automatically generate a `README.md` with installation instructions and usage details.
+
+#### Example Project Description Prompt
+
+```
+I need a Flask-based web application for managing a book library. The application should include:
+- User authentication (login, registration, password reset).
+- Models for Users, Books, and Authors using SQLAlchemy.
+- A REST API with routes for adding, updating, and deleting books and authors.
+- An admin dashboard for managing users and viewing statistics.
+- HTML templates for user login, book list, and book detail views.
+- The database should use PostgreSQL.
+- Include environment-specific configurations for development and production.
+```
+
+ScriptMonkey will use this description to create a project structure and code files for you in a directory named `generated_project`.
+
+### Error Handling with `scriptmonkey.run()`
+
+ScriptMonkey doesn't just build projects; it also makes debugging a breeze.
+
+1. Import `scriptmonkey` in your Python script.
+2. Call `scriptmonkey.run()` to activate the error handler.
+3. Run your code, and let ScriptMonkey handle any errors that occur.
+
+#### Example
+
+```python
+import scriptmonkey
+
+# Enable ScriptMonkey's error handler
+scriptmonkey.run()
+
+# Intentional error for testing
+def add(a, b):
+    return a + b  # This will fail if b is a string
+
+print(add(2, "3"))  # ScriptMonkey will automatically fix this error and update the file.
+```
+
+Once an error occurs, ScriptMonkey will:
+1. Detect the error.
+2. Send the error and code to OpenAI for analysis.
+3. Provide a solution and automatically update the file with the corrected code.
+
+### Setting or Updating Your OpenAI API Key
+
+If you haven't set your OpenAI API key yet or need to update it, you can do so with the following command:
+
+```bash
+python3 -m scriptmonkey --set-api-key your-api-key
+```
+
+This will store the API key in a config locally and use it for all future interactions with OpenAI.
+
+## Requirements
+- Python 3.6 or later
+- An OpenAI API key (follow the steps below if you don't have one)
+
+## Obtaining an OpenAI API Key
+
+1. Go to the OpenAI website: [OpenAI Platform](https://platform.openai.com/)
+2. Sign up or log in to your account.
+3. Navigate to the **API keys** section in your account dashboard.
+4. Create a new API key and copy it.
+
+## Configuring the API Key for ScriptMonkey
+
+- **Option 1: Environment Variable**  
+  You can set up your API key as an environment variable:
+
+  ```bash
+  export OPENAI_API_KEY='your-api-key'
+  ```
+
+- **Option 2: Entering the API Key When Prompted**  
+  If ScriptMonkey does not find an API key in your environment variables, it will prompt you to enter your key. Once entered, it will save the key to a configuration file for future use.
+
+- **Option 3: Using the `--set-api-key` Command**  
+  Use the `--set-api-key` command as shown above to set or update your API key easily.
+
+Let ScriptMonkey take care of your Python errors and project setup so you can focus on building!

scriptmonkey-1.0.0/README.md

@@ -0,0 +1,122 @@
+
+# ScriptMonkey 🐒
+
+ScriptMonkey is an AI-powered Python package that reimagines how projects are built. It doesn’t just generate simple scripts or templates like traditional LLMs—it creates **entire, multi-file, multi-directory projects with fully custom code**. Complex Python projects can be generated in seconds based on your natural language descriptions, providing everything you need, from models and routes to templates and configuration files. With ScriptMonkey, you can instantly bootstrap new ideas or start complex projects without the tedious setup. And with built-in error detection and automatic fixes, ScriptMonkey keeps your development process smooth and stress-free, letting you focus on what matters most: building.
+
+## Features
+- **Custom Project Generation**: Create entire Python projects, not just boilerplate code. ScriptMonkey generates the specific files and directories you need based on your description.
+- **Lightning-Fast Setup**: Complex Python projects can be generated in seconds, saving you time and effort.
+- **Automatic Error Detection**: Captures errors during runtime.
+- **AI-Powered Fixes**: Uses OpenAI's GPT API to understand and resolve errors.
+- **Code Auto-Correction**: Automatically updates your Python files with the fixes.
+- **Cross-IDE Compatibility**: Works with any IDE or code editor.
+
+## Installation
+
+To install ScriptMonkey, simply run:
+
+```bash
+pip install scriptmonkey
+```
+
+## Usage
+
+### Project Generation with `python3 -m scriptmonkey`
+
+ScriptMonkey can generate a complete, custom-coded project structure based on a description you provide. This feature helps you quickly set up new projects with the necessary files and folders.
+
+#### How to Use
+
+1. Run the following command in your terminal:
+
+   ```bash
+   python3 -m scriptmonkey
+   ```
+
+2. A text editor will open (e.g., `nano`, `vim`, or `notepad` depending on your environment). Follow the on-screen instructions to provide a detailed description of your project.
+
+3. Save and close the editor. ScriptMonkey will then:
+   - Generate a complete project structure based on your description.
+   - Create directories, code files, and templates.
+   - Automatically generate a `README.md` with installation instructions and usage details.
+
+#### Example Project Description Prompt
+
+```
+I need a Flask-based web application for managing a book library. The application should include:
+- User authentication (login, registration, password reset).
+- Models for Users, Books, and Authors using SQLAlchemy.
+- A REST API with routes for adding, updating, and deleting books and authors.
+- An admin dashboard for managing users and viewing statistics.
+- HTML templates for user login, book list, and book detail views.
+- The database should use PostgreSQL.
+- Include environment-specific configurations for development and production.
+```
+
+ScriptMonkey will use this description to create a project structure and code files for you in a directory named `generated_project`.
+
+### Error Handling with `scriptmonkey.run()`
+
+ScriptMonkey doesn't just build projects; it also makes debugging a breeze.
+
+1. Import `scriptmonkey` in your Python script.
+2. Call `scriptmonkey.run()` to activate the error handler.
+3. Run your code, and let ScriptMonkey handle any errors that occur.
+
+#### Example
+
+```python
+import scriptmonkey
+
+# Enable ScriptMonkey's error handler
+scriptmonkey.run()
+
+# Intentional error for testing
+def add(a, b):
+    return a + b  # This will fail if b is a string
+
+print(add(2, "3"))  # ScriptMonkey will automatically fix this error and update the file.
+```
+
+Once an error occurs, ScriptMonkey will:
+1. Detect the error.
+2. Send the error and code to OpenAI for analysis.
+3. Provide a solution and automatically update the file with the corrected code.
+
+### Setting or Updating Your OpenAI API Key
+
+If you haven't set your OpenAI API key yet or need to update it, you can do so with the following command:
+
+```bash
+python3 -m scriptmonkey --set-api-key your-api-key
+```
+
+This will store the API key in a config locally and use it for all future interactions with OpenAI.
+
+## Requirements
+- Python 3.6 or later
+- An OpenAI API key (follow the steps below if you don't have one)
+
+## Obtaining an OpenAI API Key
+
+1. Go to the OpenAI website: [OpenAI Platform](https://platform.openai.com/)
+2. Sign up or log in to your account.
+3. Navigate to the **API keys** section in your account dashboard.
+4. Create a new API key and copy it.
+
+## Configuring the API Key for ScriptMonkey
+
+- **Option 1: Environment Variable**  
+  You can set up your API key as an environment variable:
+
+  ```bash
+  export OPENAI_API_KEY='your-api-key'
+  ```
+
+- **Option 2: Entering the API Key When Prompted**  
+  If ScriptMonkey does not find an API key in your environment variables, it will prompt you to enter your key. Once entered, it will save the key to a configuration file for future use.
+
+- **Option 3: Using the `--set-api-key` Command**  
+  Use the `--set-api-key` command as shown above to set or update your API key easily.
+
+Let ScriptMonkey take care of your Python errors and project setup so you can focus on building!

{scriptmonkey-0.1.1 → scriptmonkey-1.0.0}/scriptmonkey/__init__.py

@@ -1 +1,2 @@
 from .core import run
+

scriptmonkey-1.0.0/scriptmonkey/__main__.py

@@ -0,0 +1,4 @@
+from .core import main
+
+if __name__ == "__main__":
+    main()

scriptmonkey-1.0.0/scriptmonkey/core.py

@@ -0,0 +1,321 @@
+import sys
+import traceback
+from .openai_client import chatgpt_json, chatgpt, ScriptMonkeyResponse, ProjectStructureResponse, ProjectFile, default_prompts
+from .openai_client.prompting import load_prompt
+from .file_handler import read_file, write_file
+import platform
+import tempfile
+import subprocess
+import threading
+import itertools
+import time
+from pprint import pprint
+import os
+import platform
+
+def get_platform():
+    os_name = platform.system()
+    os_version = platform.release()
+    return f"# Operating System: {os_name}, Version: {os_version}\n\n"
+
+class Spinner:
+    def __init__(self, message="Processing"):
+        self.spinner = itertools.cycle(["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"])
+        self.stop_running = threading.Event()
+        self.spin_thread = None
+        self.message = message
+
+    def spin(self):
+        while not self.stop_running.is_set():
+            sys.stdout.write(f"\r{self.message} {next(self.spinner)}")
+            sys.stdout.flush()
+            time.sleep(0.1)
+        sys.stdout.write("\r" + " " * (len(self.message) + 2) + "\r")
+        sys.stdout.flush()
+
+    def __enter__(self):
+        self.spin_thread = threading.Thread(target=self.spin)
+        self.spin_thread.start()
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.stop_running.set()
+        self.spin_thread.join()
+
+def codemonkey_exception_handler(exc_type, exc_value, exc_traceback):
+    if issubclass(exc_type, KeyboardInterrupt):
+        sys.__excepthook__(exc_type, exc_value, exc_traceback)
+        return
+
+    error_message = "".join(traceback.format_exception(exc_type, exc_value, exc_traceback))
+
+    print(f"\n🐒 ScriptMonkey Detected an Error:")
+    print(error_message, "\n")
+
+    frame = traceback.extract_tb(exc_traceback)[-1]
+    file_path = frame.filename
+
+    original_code = read_file(file_path)
+    content = f"{get_platform()}# Original Code:\n```\n{original_code}\n```\n\n# Error Message:\n{error_message}"
+
+    solution = None
+    with Spinner("🐒 ScriptMonkey is working on a solution"):
+        solution = chatgpt_json(
+            instructions=default_prompts.fix_error, content=content, response_format=ScriptMonkeyResponse
+        )
+
+    print(f"\n🐒 ScriptMonkey Fixed It:\nProblem:\n{solution['problem']}\n")
+    print(f"Suggested Solution:\n{solution['solution']}\n")
+
+    corrected_code = solution["corrected_code"].replace("```python", "").replace("```", "")
+    write_file(file_path, corrected_code)
+    print(f"🐒 ScriptMonkey automatically fixed your code at: '{file_path}'.")
+
+
+def run():
+    sys.excepthook = codemonkey_exception_handler
+
+
+# - - - - - API KEY MANAGEMENT - - - - -
+
+def save_api_key(api_key: str):
+    """Save the OpenAI API key to the configuration file and environment variable."""
+    with open(CONFIG_FILE, 'w') as file:
+        file.write(api_key)
+    os.environ['OPENAI_API_KEY'] = api_key
+    print(f"✅ OpenAI API key saved to {CONFIG_FILE}.")
+
+def get_openai_api_key() -> str:
+    """Retrieve the OpenAI API key from environment or configuration file."""
+    api_key = os.getenv('OPENAI_API_KEY')
+    
+    if not api_key:
+        # Check for API key in the configuration file
+        if os.path.exists(CONFIG_FILE):
+            with open(CONFIG_FILE, 'r') as file:
+                api_key = file.read().strip()
+
+    # Prompt user for API key if not found
+    if not api_key:
+        print("🐒 ScriptMonkey requires an OpenAI API key to function.")
+        api_key = getpass.getpass("Please enter your OpenAI API key (input hidden): ")
+        
+        if api_key:
+            save_api_key(api_key)
+    
+    if not api_key:
+        print("❌ No API key provided. Exiting ScriptMonkey.")
+        sys.exit(1)
+    
+    return api_key
+
+def update_api_key():
+    """Prompt the user to update the OpenAI API key."""
+    api_key = getpass.getpass("Enter the new OpenAI API key (input hidden): ")
+    if api_key:
+        save_api_key(api_key)
+        print("✅ OpenAI API key updated successfully.")
+    else:
+        print("❌ No API key provided. The API key was not updated.")
+
+# - - - - - NEW FEATURES - - - - -
+
+def get_multiline_input_with_editor() -> str:
+    """
+    Opens the user's default text editor for entering multi-line input.
+    The user is provided with instructions within the temporary file,
+    adjusted based on the detected editor.
+    """
+    with tempfile.NamedTemporaryFile(suffix=".txt") as temp_file:
+        # Detect the editor from the environment or default based on the OS
+        editor = os.environ.get('EDITOR')
+
+        # If no editor is set, choose a default based on the platform
+        if not editor:
+            if platform.system() == 'Windows':
+                editor = 'notepad'
+            else:
+                editor = 'nano'  # Default for Unix-like systems
+
+        # Adjust instructions based on the detected editor
+        if 'vim' in editor.lower():
+            instructions = (
+                "!# 🐒 Welcome to ScriptMonkey's project generator!\n"
+                "!# Please describe your project in detail below.\n"
+                "!# Use 'i' to start editing, and when you're done, press 'Esc',\n"
+                "!# type ':wq' to save and exit.\n"
+                "!# (Lines starting with '!#' will be ignored.)\n\n"
+            )
+        elif 'nano' in editor.lower():
+            instructions = (
+                "!# 🐒 Welcome to ScriptMonkey's project generator!\n"
+                "!# Please describe your project in detail below.\n"
+                "!# When you're done, press 'Ctrl+O' to save and 'Ctrl+X' to exit.\n"
+                "!# (Lines starting with '!#' will be ignored.)\n\n"
+            )
+        elif 'notepad' in editor.lower():
+            instructions = (
+                "!# 🐒 Welcome to ScriptMonkey's project generator!\n"
+                "!# Please describe your project in detail below.\n"
+                "!# When you're done, save and close the Notepad window.\n"
+                "!# (Lines starting with '!#' will be ignored.)\n\n"
+            )
+        elif 'code' in editor.lower():
+            instructions = (
+                "!# 🐒 Welcome to ScriptMonkey's project generator!\n"
+                "!# Please describe your project in detail below.\n"
+                "!# When you're done, save the file and close the editor window.\n"
+                "!# (Lines starting with '!#' will be ignored.)\n\n"
+            )
+        else:
+            instructions = (
+                "!# 🐒 Welcome to ScriptMonkey's project generator!\n"
+                "!# Please describe your project in detail below.\n"
+                "!# Save and close the editor when you're done.\n"
+                "!# (Lines starting with '!#' will be ignored.)\n\n"
+            )
+
+        # Write the instructions to the temporary file
+        temp_file.write(instructions.encode('utf-8'))
+        temp_file.flush()
+
+        # Open the temporary file in the detected editor
+        subprocess.call([editor, temp_file.name])
+
+        # Read the user's input, ignoring lines starting with '!#'
+        temp_file.seek(0)
+        user_input = temp_file.read().decode('utf-8')
+        user_input = "\n".join(line for line in user_input.splitlines() if not line.startswith("!#"))
+
+    return user_input.strip()
+
+def generate_project_structure(description: str) -> ProjectStructureResponse:
+    """Generates the project structure based on the user's project description using OpenAI."""
+    instructions = (
+        "Generate a detailed project structure for a multi-level application. The project will be placed directly inside a folder named 'generated_project'."
+        "\n- Do NOT include 'generated_project/' as part of the paths. All paths should be relative to the root of the project directory, meaning they should start directly with the file or folder names as if they are inside 'generated_project'."
+        "\n- Provide a list of directories and files with their full relative paths."
+        "\n- Each directory should end with a '/' to indicate that it is a folder."
+        "\n- For each file or directory, include a 'description' that explains its purpose."
+        "\n- If the file is a Python code file, also include a 'functions' list. For each function, include:"
+        "\n  - 'function_name': The name of the function."
+        "\n  - 'description': A description of what the function does."
+        "\n  - 'inputs': A list of the function's expected inputs, including data types."
+        "\n  - 'outputs': A list of the function's expected outputs, including data types."
+        "\n- Do not include any extra explanations, commentary, or introductory text. Only provide the structured data as requested."
+    )
+
+    # Call the chatgpt_json function to get structured project plan
+    project_structure = chatgpt_json(
+        instructions=instructions, 
+        content=description, 
+        response_format=ProjectStructureResponse
+    )
+    
+    return project_structure
+
+def create_project_structure(project_structure_response: dict, base_directory: str = "./generated_project"):
+    """Creates the directories and files for the project and generates code content for code files."""
+    for project_file in project_structure_response['files']:
+        file_path = os.path.join(base_directory, project_file['path'].lstrip('/'))
+
+        # Check if it's a directory or file (directories end with '/')
+        if file_path.endswith('/'):
+            os.makedirs(file_path, exist_ok=True)
+            print(f"🐒 ScriptMonkey created directory: {file_path}")
+        else:
+            os.makedirs(os.path.dirname(file_path), exist_ok=True)
+
+            # If it's a Python code file, generate code and write to the file
+            if file_path.endswith('.py'):
+                generated_code = generate_code_for_file(project_file)
+                if not os.path.exists(file_path):
+                    with open(file_path, 'w') as f:
+                        f.write(generated_code)
+                    print(f"🐒 ScriptMonkey created file with generated code at: '{file_path}'.")
+                else:
+                    print(f"File already exists, skipping: {file_path}")
+            else:
+                # Create other file types (HTML, CSS, etc.)
+                if not os.path.exists(file_path):
+                    with open(file_path, 'w') as f:
+                        pass  # Create an empty file for non-code files
+                    print(f"🐒 ScriptMonkey reated file: {file_path}")
+                else:
+                    print(f"File already exists, skipping: {file_path}")
+
+
+def generate_code_for_file(file_description: dict) -> str:
+    """Generates code content for a given file based on its description using the chatgpt() function."""
+    # Prepare instructions for OpenAI to generate code based on the file description
+    instructions = (
+        "Write the complete Python code based on the following file description without adding any additional commentary or explanation. "
+        "Ensure the code follows PEP8 standards, includes type hints, and contains relevant docstrings."
+        f"\n\nFile Description: {file_description['description']}"
+    )
+
+    # Check if the file has functions to include in the code
+    if file_description.get('functions'):
+        instructions += "\n\nFunctions:\n"
+        for function in file_description['functions']:
+            instructions += (
+                f"- {function['function_name']}: {function['description']} "
+                f"(Inputs: {function['inputs']}, Outputs: {function['outputs']})\n"
+            )
+
+    # Call the chatgpt function to generate the code
+    generated_code = chatgpt(prompt=instructions)
+    
+    # Strip out any unintended extra explanations that might still slip through
+    if "```python" in generated_code:
+        generated_code = generated_code.split("```python")[1].split("```")[0].strip()
+    
+    return generated_code
+
+def generate_readme(description: str, project_structure: dict) -> str:
+    """Generates a README.md content based on the project description and structure."""
+    instructions = (
+        "Write a complete README.md file based on the following project details. "
+        "The README should include the project overview, installation instructions, usage guide, file structure summary, key features, and configuration details. "
+        "Make sure the README is well-structured and formatted using Markdown without wrapping the entire README in backticks or any other non-readme commentary."
+        "Do not include any commentary, explanations, or text outside of the README content."
+        f"\n\nProject Description: {description}\n"
+        f"\nProject Structure: {project_structure}\n"
+    )
+
+    readme_content = chatgpt(prompt=instructions)
+    readme_content = readme_content.strip("```markdown").strip("```")
+    return readme_content
+
+
+# Example usage
+def main():
+    if len(sys.argv) > 1 and sys.argv[1] == '--set-api-key':
+        update_api_key()
+    else:
+        print(f"\n- - 🐒 WELCOME TO SCRIPT MONKEY 🐒 - - -\n")
+        print(f"Opening prompt editor... ")
+        time.sleep(2)
+
+        # Step 1: Get multi-line project description from user
+        project_description = get_multiline_input_with_editor()
+        if not project_description:
+            print(f"\nNo Project Description Provided (Tip: Did you save before closing the editor?).\n🐒 Quitting ScriptMonkey...")
+            exit()
+        print(f"Project Description: {project_description}")
+
+        # Step 2: Generate the project structure using OpenAI API
+        project_structure = generate_project_structure(project_description)
+        print(f"\n🐒 ScriptMonkey created a project blueprint:")
+        pprint(project_structure)
+
+        # Step 3: Create the project structure (directories and files) on the filesystem
+        print(f"\n🐒 ScriptMonkey is coding...")
+        create_project_structure(project_structure)
+        print("\nProject structure creation complete.")
+
+        # Step 4: Generate the README.md content based on the project description and structure
+        readme_content = generate_readme(project_description, project_structure)
+        readme_path = "./generated_project/README.md"
+        with open(readme_path, 'w') as readme_file:
+            readme_file.write(readme_content)
+        print(f"🐒 ScriptMonkey wrote a README.md file at: '{readme_path}'")

scriptmonkey-1.0.0/scriptmonkey/openai_client/__init__.py

@@ -0,0 +1,28 @@
+from .prompting import DefaultPrompts
+from .client import chatgpt_json, chatgpt
+from pydantic import BaseModel
+from typing import List, Optional
+
+class FunctionDetails(BaseModel):
+    function_name: str
+    description: str
+    inputs: Optional[List[str]]  # List of inputs with data types
+    outputs: Optional[List[str]]  # List of outputs with data types
+
+
+class ProjectFile(BaseModel):
+    path: str  # The full path to the file or directory
+    description: str  # High-level purpose of the directory or file
+    functions: Optional[List[FunctionDetails]]  # List of functions/classes if it's a code file
+
+class ProjectStructureResponse(BaseModel):
+    files: List[ProjectFile]  # List of all files and directories in the project
+
+
+class ScriptMonkeyResponse(BaseModel):
+    problem: str  # A description of the error/problem
+    solution: str  # The solution to the problem
+    corrected_code: str  # The corrected version of the Python code
+
+
+default_prompts = DefaultPrompts()

{scriptmonkey-0.1.1 → scriptmonkey-1.0.0}/scriptmonkey/openai_client/client.py

@@ -4,14 +4,37 @@ from dotenv import load_dotenv
 from pydantic import BaseModel
 import openai
 
-# Load the OpenAI API key from .env file
+CONFIG_FILE = os.path.expanduser("~/.scriptmonkey_config")
+
+# Load environment variables from the .env file if present
 load_dotenv()
-OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
-if OPENAI_API_KEY:
-    # Initialize openai API client
-    client = openai.OpenAI(api_key=OPENAI_API_KEY)
-else:
-    raise ValueError("Missing OpenAI API Key. Please check your environment variables.")
+
+def get_openai_api_key():
+    # Try to get the API key from environment variables
+    api_key = os.getenv("OPENAI_API_KEY")
+    
+    # If not set, check the config file
+    if not api_key and os.path.exists(CONFIG_FILE):
+        with open(CONFIG_FILE, 'r') as f:
+            api_key = f.read().strip()
+
+    # If still not set, prompt the user for it
+    if not api_key:
+        print("It looks like your OpenAI API key isn't set.")
+        api_key = input("🐒 Please paste your OpenAI API key here and press ENTER: ").strip()
+        
+        # Save the key to the config file for future use
+        with open(CONFIG_FILE, 'w') as f:
+            f.write(api_key)
+        print(f"Your API key has been saved to {CONFIG_FILE} for future use.")
+
+    return api_key
+
+# Get the OpenAI API key using the function
+OPENAI_API_KEY = get_openai_api_key()
+
+# Initialize the OpenAI client with the obtained API key
+client = openai.OpenAI(api_key=OPENAI_API_KEY)
 
 
 def chatgpt_json(instructions: str, content: str, response_format: BaseModel) -> dict:

scriptmonkey-1.0.0/scriptmonkey/openai_client/prompts/project_description.txt

@@ -0,0 +1 @@
+Build a Flask web application with user authentication, a PostgreSQL database, and an admin dashboard.

scriptmonkey-1.0.0/scriptmonkey.egg-info/PKG-INFO

@@ -0,0 +1,141 @@
+Metadata-Version: 2.1
+Name: scriptmonkey
+Version: 1.0.0
+Summary: A Python package that generates complex Python projects and fixes errors in your code using OpenAI's GPT API.
+Home-page: https://github.com/lukerbs/ScriptMonkey
+Author: Luke Kerbs
+Author-email: LDK.kerbs@gmail.com
+License: MIT
+Keywords: openai,GPT,AI,project generation,multi-file project,complex project generator,code error fixing,code automation,GPT API,error correction,code assistant,AI coding tools,script monkey,automation,development tools,python tools,code analysis,machine learning,project bootstrap,custom code generation,python package
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+Requires-Dist: openai
+Requires-Dist: pydantic
+Requires-Dist: tqdm
+Requires-Dist: python-dotenv
+
+
+# ScriptMonkey 🐒
+
+ScriptMonkey is an AI-powered Python package that reimagines how projects are built. It doesn’t just generate simple scripts or templates like traditional LLMs—it creates **entire, multi-file, multi-directory projects with fully custom code**. Complex Python projects can be generated in seconds based on your natural language descriptions, providing everything you need, from models and routes to templates and configuration files. With ScriptMonkey, you can instantly bootstrap new ideas or start complex projects without the tedious setup. And with built-in error detection and automatic fixes, ScriptMonkey keeps your development process smooth and stress-free, letting you focus on what matters most: building.
+
+## Features
+- **Custom Project Generation**: Create entire Python projects, not just boilerplate code. ScriptMonkey generates the specific files and directories you need based on your description.
+- **Lightning-Fast Setup**: Complex Python projects can be generated in seconds, saving you time and effort.
+- **Automatic Error Detection**: Captures errors during runtime.
+- **AI-Powered Fixes**: Uses OpenAI's GPT API to understand and resolve errors.
+- **Code Auto-Correction**: Automatically updates your Python files with the fixes.
+- **Cross-IDE Compatibility**: Works with any IDE or code editor.
+
+## Installation
+
+To install ScriptMonkey, simply run:
+
+```bash
+pip install scriptmonkey
+```
+
+## Usage
+
+### Project Generation with `python3 -m scriptmonkey`
+
+ScriptMonkey can generate a complete, custom-coded project structure based on a description you provide. This feature helps you quickly set up new projects with the necessary files and folders.
+
+#### How to Use
+
+1. Run the following command in your terminal:
+
+   ```bash
+   python3 -m scriptmonkey
+   ```
+
+2. A text editor will open (e.g., `nano`, `vim`, or `notepad` depending on your environment). Follow the on-screen instructions to provide a detailed description of your project.
+
+3. Save and close the editor. ScriptMonkey will then:
+   - Generate a complete project structure based on your description.
+   - Create directories, code files, and templates.
+   - Automatically generate a `README.md` with installation instructions and usage details.
+
+#### Example Project Description Prompt
+
+```
+I need a Flask-based web application for managing a book library. The application should include:
+- User authentication (login, registration, password reset).
+- Models for Users, Books, and Authors using SQLAlchemy.
+- A REST API with routes for adding, updating, and deleting books and authors.
+- An admin dashboard for managing users and viewing statistics.
+- HTML templates for user login, book list, and book detail views.
+- The database should use PostgreSQL.
+- Include environment-specific configurations for development and production.
+```
+
+ScriptMonkey will use this description to create a project structure and code files for you in a directory named `generated_project`.
+
+### Error Handling with `scriptmonkey.run()`
+
+ScriptMonkey doesn't just build projects; it also makes debugging a breeze.
+
+1. Import `scriptmonkey` in your Python script.
+2. Call `scriptmonkey.run()` to activate the error handler.
+3. Run your code, and let ScriptMonkey handle any errors that occur.
+
+#### Example
+
+```python
+import scriptmonkey
+
+# Enable ScriptMonkey's error handler
+scriptmonkey.run()
+
+# Intentional error for testing
+def add(a, b):
+    return a + b  # This will fail if b is a string
+
+print(add(2, "3"))  # ScriptMonkey will automatically fix this error and update the file.
+```
+
+Once an error occurs, ScriptMonkey will:
+1. Detect the error.
+2. Send the error and code to OpenAI for analysis.
+3. Provide a solution and automatically update the file with the corrected code.
+
+### Setting or Updating Your OpenAI API Key
+
+If you haven't set your OpenAI API key yet or need to update it, you can do so with the following command:
+
+```bash
+python3 -m scriptmonkey --set-api-key your-api-key
+```
+
+This will store the API key in a config locally and use it for all future interactions with OpenAI.
+
+## Requirements
+- Python 3.6 or later
+- An OpenAI API key (follow the steps below if you don't have one)
+
+## Obtaining an OpenAI API Key
+
+1. Go to the OpenAI website: [OpenAI Platform](https://platform.openai.com/)
+2. Sign up or log in to your account.
+3. Navigate to the **API keys** section in your account dashboard.
+4. Create a new API key and copy it.
+
+## Configuring the API Key for ScriptMonkey
+
+- **Option 1: Environment Variable**  
+  You can set up your API key as an environment variable:
+
+  ```bash
+  export OPENAI_API_KEY='your-api-key'
+  ```
+
+- **Option 2: Entering the API Key When Prompted**  
+  If ScriptMonkey does not find an API key in your environment variables, it will prompt you to enter your key. Once entered, it will save the key to a configuration file for future use.
+
+- **Option 3: Using the `--set-api-key` Command**  
+  Use the `--set-api-key` command as shown above to set or update your API key easily.
+
+Let ScriptMonkey take care of your Python errors and project setup so you can focus on building!

{scriptmonkey-0.1.1 → scriptmonkey-1.0.0}/scriptmonkey.egg-info/SOURCES.txt

@@ -1,15 +1,18 @@
 README.md
 setup.py
 scriptmonkey/__init__.py
+scriptmonkey/__main__.py
 scriptmonkey/core.py
 scriptmonkey/file_handler.py
 scriptmonkey.egg-info/PKG-INFO
 scriptmonkey.egg-info/SOURCES.txt
 scriptmonkey.egg-info/dependency_links.txt
+scriptmonkey.egg-info/entry_points.txt
 scriptmonkey.egg-info/requires.txt
 scriptmonkey.egg-info/top_level.txt
 scriptmonkey/openai_client/__init__.py
 scriptmonkey/openai_client/basemodels.py
 scriptmonkey/openai_client/client.py
 scriptmonkey/openai_client/prompting.py
-scriptmonkey/openai_client/prompts/fix_error.txt
+scriptmonkey/openai_client/prompts/fix_error.txt
+scriptmonkey/openai_client/prompts/project_description.txt

scriptmonkey-1.0.0/scriptmonkey.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+scriptmonkey = scriptmonkey.core:main

{scriptmonkey-0.1.1 → scriptmonkey-1.0.0}/scriptmonkey.egg-info/requires.txt

@@ -1,3 +1,4 @@
 openai
 pydantic
 tqdm
+python-dotenv

{scriptmonkey-0.1.1 → scriptmonkey-1.0.0}/setup.py

@@ -2,17 +2,22 @@ from setuptools import setup, find_packages
 
 setup(
     name="scriptmonkey",
-    version="0.1.1",  # Incremented version
-    description="A Python package that automatically fixes errors in your code using OpenAI's GPT API",
+    version="1.0.0",
+    description="A Python package that generates complex Python projects and fixes errors in your code using OpenAI's GPT API.",
     long_description=open("README.md", "r").read(),
     long_description_content_type="text/markdown",
-    url="https://github.com/lukerbs/CodeMonkey",
+    url="https://github.com/lukerbs/ScriptMonkey",
     author="Luke Kerbs",
     author_email="LDK.kerbs@gmail.com",
     license="MIT",
     packages=find_packages(),
-    install_requires=["openai", "pydantic", "tqdm"],
-    python_requires=">=3.6",  # Minimum Python version
+    install_requires=["openai", "pydantic", "tqdm", "python-dotenv"],
+    python_requires=">=3.6",
+    entry_points={
+        "console_scripts": [
+            "scriptmonkey=scriptmonkey.core:main",
+        ],
+    },
     classifiers=[
         "Programming Language :: Python :: 3",
         "License :: OSI Approved :: MIT License",
@@ -22,20 +27,25 @@ setup(
         "openai",
         "GPT",
         "AI",
+        "project generation",
+        "multi-file project",
+        "complex project generator",
         "code error fixing",
         "code automation",
         "GPT API",
         "error correction",
         "code assistant",
         "AI coding tools",
-        "code monkey",
         "script monkey",
         "automation",
         "development tools",
         "python tools",
         "code analysis",
         "machine learning",
-    ],  # Added relevant keywords
+        "project bootstrap",
+        "custom code generation",
+        "python package",
+    ],
     package_data={"scriptmonkey.openai_client": ["prompts/*.txt"]},
     include_package_data=True,
-)
+)

scriptmonkey-0.1.1/PKG-INFO

@@ -1,84 +0,0 @@
-Metadata-Version: 2.1
-Name: scriptmonkey
-Version: 0.1.1
-Summary: A Python package that automatically fixes errors in your code using OpenAI's GPT API
-Home-page: https://github.com/lukerbs/CodeMonkey
-Author: Luke Kerbs
-Author-email: LDK.kerbs@gmail.com
-License: MIT
-Keywords: openai,GPT,AI,code error fixing,code automation,GPT API,error correction,code assistant,AI coding tools,code monkey,script monkey,automation,development tools,python tools,code analysis,machine learning
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.6
-Description-Content-Type: text/markdown
-Requires-Dist: openai
-Requires-Dist: pydantic
-Requires-Dist: tqdm
-
-
-# ScriptMonkey 🐒
-
-ScriptMonkey is a Python package that automatically detects and fixes errors in your code using OpenAI's GPT API. It works with any IDE or code editor, analyzing your code at runtime, providing solutions to errors, and even updating the file with the corrected code.
-
-## Features
-- **Automatic error detection**: Captures errors during runtime.
-- **AI-powered fixes**: Uses OpenAI's GPT API to understand and resolve errors.
-- **Code auto-correction**: Automatically updates your Python files with the fixes.
-- **Cross-IDE compatibility**: Works with any IDE or code editor.
-
-## Installation
-
-To install ScriptMonkey, simply run:
-
-```bash
-pip install scriptmonkey
-```
-
-## Usage
-
-1. Import `scriptmonkey` in your Python script.
-2. Call `scriptmonkey.run()` to activate the error handler.
-3. Run your code, and let ScriptMonkey handle any errors that occur.
-
-### Example
-
-```python
-import scriptmonkey
-
-# Enable Codemonkey's error handler
-scriptmonkey.run()
-
-# Intentional error for testing
-def add(a, b):
-    return a + b  # This will fail if b is a string
-
-print(add(2, "3"))  # Codemonkey will automatically fix this error and update the file
-```
-
-Once an error occurs, ScriptMonkey will:
-1. Detect the error.
-2. Send the error and code to OpenAI for analysis.
-3. Provide a solution and automatically update the file with the correct code.
-
-## How It Works
-
-ScriptMonkey replaces Python's default exception handling with a custom handler. When an error is caught, it:
-- Collects the traceback and the Python file that caused the error.
-- Sends the error message and code to OpenAI.
-- Receives the solution as structured JSON.
-- Applies the fix directly to the source file.
-
-## Requirements
-- Python 3.6 or later
-- OpenAI API key
-
-## Setup
-
-To use ScriptMonkey, you'll need an OpenAI API key. Set it up as follows:
-
-```bash
-export OPENAI_API_KEY='your-api-key'
-```
-
-Let ScriptMonkey take care of your Python errors so you can focus on building!

scriptmonkey-0.1.1/README.md

@@ -1,66 +0,0 @@
-
-# ScriptMonkey 🐒
-
-ScriptMonkey is a Python package that automatically detects and fixes errors in your code using OpenAI's GPT API. It works with any IDE or code editor, analyzing your code at runtime, providing solutions to errors, and even updating the file with the corrected code.
-
-## Features
-- **Automatic error detection**: Captures errors during runtime.
-- **AI-powered fixes**: Uses OpenAI's GPT API to understand and resolve errors.
-- **Code auto-correction**: Automatically updates your Python files with the fixes.
-- **Cross-IDE compatibility**: Works with any IDE or code editor.
-
-## Installation
-
-To install ScriptMonkey, simply run:
-
-```bash
-pip install scriptmonkey
-```
-
-## Usage
-
-1. Import `scriptmonkey` in your Python script.
-2. Call `scriptmonkey.run()` to activate the error handler.
-3. Run your code, and let ScriptMonkey handle any errors that occur.
-
-### Example
-
-```python
-import scriptmonkey
-
-# Enable Codemonkey's error handler
-scriptmonkey.run()
-
-# Intentional error for testing
-def add(a, b):
-    return a + b  # This will fail if b is a string
-
-print(add(2, "3"))  # Codemonkey will automatically fix this error and update the file
-```
-
-Once an error occurs, ScriptMonkey will:
-1. Detect the error.
-2. Send the error and code to OpenAI for analysis.
-3. Provide a solution and automatically update the file with the correct code.
-
-## How It Works
-
-ScriptMonkey replaces Python's default exception handling with a custom handler. When an error is caught, it:
-- Collects the traceback and the Python file that caused the error.
-- Sends the error message and code to OpenAI.
-- Receives the solution as structured JSON.
-- Applies the fix directly to the source file.
-
-## Requirements
-- Python 3.6 or later
-- OpenAI API key
-
-## Setup
-
-To use ScriptMonkey, you'll need an OpenAI API key. Set it up as follows:
-
-```bash
-export OPENAI_API_KEY='your-api-key'
-```
-
-Let ScriptMonkey take care of your Python errors so you can focus on building!

scriptmonkey-0.1.1/scriptmonkey/core.py

@@ -1,72 +0,0 @@
-import sys
-import traceback
-from .openai_client import chatgpt_json, ScriptMonkeyResponse, default_prompts
-from .file_handler import read_file, write_file
-import platform
-import threading
-import itertools
-import time
-
-
-def get_platform():
-    os_name = platform.system()
-    os_version = platform.release()
-    return f"# Operating System: {os_name}, Version: {os_version}\n\n"
-
-
-class Spinner:
-    def __init__(self, message="Processing"):
-        self.spinner = itertools.cycle(["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"])
-        self.stop_running = threading.Event()
-        self.spin_thread = None
-        self.message = message
-
-    def spin(self):
-        while not self.stop_running.is_set():
-            sys.stdout.write(f"\r{self.message} {next(self.spinner)}")
-            sys.stdout.flush()
-            time.sleep(0.1)
-        sys.stdout.write("\r" + " " * (len(self.message) + 2) + "\r")
-        sys.stdout.flush()
-
-    def __enter__(self):
-        self.spin_thread = threading.Thread(target=self.spin)
-        self.spin_thread.start()
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        self.stop_running.set()
-        self.spin_thread.join()
-
-
-def codemonkey_exception_handler(exc_type, exc_value, exc_traceback):
-    if issubclass(exc_type, KeyboardInterrupt):
-        sys.__excepthook__(exc_type, exc_value, exc_traceback)
-        return
-
-    error_message = "".join(traceback.format_exception(exc_type, exc_value, exc_traceback))
-
-    print(f"\n🐒 ScriptMonkey Detected an Error:")
-    print(error_message, "\n")
-
-    frame = traceback.extract_tb(exc_traceback)[-1]
-    file_path = frame.filename
-
-    original_code = read_file(file_path)
-    content = f"{get_platform()}# Original Code:\n```\n{original_code}\n```\n\n# Error Message:\n{error_message}"
-
-    solution = None
-    with Spinner("🐒 ScriptMonkey is working on a solution"):
-        solution = chatgpt_json(
-            instructions=default_prompts.fix_error, content=content, response_format=ScriptMonkeyResponse
-        )
-
-    print(f"\n🐒 ScriptMonkey Fixed It:\nProblem:\n{solution['problem']}\n")
-    print(f"Suggested Solution:\n{solution['solution']}\n")
-
-    corrected_code = solution["corrected_code"].replace("```python", "").replace("```", "")
-    write_file(file_path, corrected_code)
-    print(f"🐒 ScriptMonkey automatically fixed your code at: '{file_path}'.")
-
-
-def run():
-    sys.excepthook = codemonkey_exception_handler

scriptmonkey-0.1.1/scriptmonkey/openai_client/__init__.py

@@ -1,12 +0,0 @@
-from .prompting import DefaultPrompts
-from .client import chatgpt_json
-from pydantic import BaseModel
-
-
-class ScriptMonkeyResponse(BaseModel):
-    problem: str  # A description of the error/problem
-    solution: str  # The solution to the problem
-    corrected_code: str  # The corrected version of the Python code
-
-
-default_prompts = DefaultPrompts()

scriptmonkey-0.1.1/scriptmonkey.egg-info/PKG-INFO

@@ -1,84 +0,0 @@
-Metadata-Version: 2.1
-Name: scriptmonkey
-Version: 0.1.1
-Summary: A Python package that automatically fixes errors in your code using OpenAI's GPT API
-Home-page: https://github.com/lukerbs/CodeMonkey
-Author: Luke Kerbs
-Author-email: LDK.kerbs@gmail.com
-License: MIT
-Keywords: openai,GPT,AI,code error fixing,code automation,GPT API,error correction,code assistant,AI coding tools,code monkey,script monkey,automation,development tools,python tools,code analysis,machine learning
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.6
-Description-Content-Type: text/markdown
-Requires-Dist: openai
-Requires-Dist: pydantic
-Requires-Dist: tqdm
-
-
-# ScriptMonkey 🐒
-
-ScriptMonkey is a Python package that automatically detects and fixes errors in your code using OpenAI's GPT API. It works with any IDE or code editor, analyzing your code at runtime, providing solutions to errors, and even updating the file with the corrected code.
-
-## Features
-- **Automatic error detection**: Captures errors during runtime.
-- **AI-powered fixes**: Uses OpenAI's GPT API to understand and resolve errors.
-- **Code auto-correction**: Automatically updates your Python files with the fixes.
-- **Cross-IDE compatibility**: Works with any IDE or code editor.
-
-## Installation
-
-To install ScriptMonkey, simply run:
-
-```bash
-pip install scriptmonkey
-```
-
-## Usage
-
-1. Import `scriptmonkey` in your Python script.
-2. Call `scriptmonkey.run()` to activate the error handler.
-3. Run your code, and let ScriptMonkey handle any errors that occur.
-
-### Example
-
-```python
-import scriptmonkey
-
-# Enable Codemonkey's error handler
-scriptmonkey.run()
-
-# Intentional error for testing
-def add(a, b):
-    return a + b  # This will fail if b is a string
-
-print(add(2, "3"))  # Codemonkey will automatically fix this error and update the file
-```
-
-Once an error occurs, ScriptMonkey will:
-1. Detect the error.
-2. Send the error and code to OpenAI for analysis.
-3. Provide a solution and automatically update the file with the correct code.
-
-## How It Works
-
-ScriptMonkey replaces Python's default exception handling with a custom handler. When an error is caught, it:
-- Collects the traceback and the Python file that caused the error.
-- Sends the error message and code to OpenAI.
-- Receives the solution as structured JSON.
-- Applies the fix directly to the source file.
-
-## Requirements
-- Python 3.6 or later
-- OpenAI API key
-
-## Setup
-
-To use ScriptMonkey, you'll need an OpenAI API key. Set it up as follows:
-
-```bash
-export OPENAI_API_KEY='your-api-key'
-```
-
-Let ScriptMonkey take care of your Python errors so you can focus on building!