gpt-shell-4o-mini 1.2.1__py3-none-any.whl

chatgpt/__init__.py

@@ -0,0 +1,24 @@
+"""
+GPT-shell-4o-mini - A simple, lightweight CLI to use OpenAI's ChatGPT and DALL-E from the terminal.
+
+This package provides a command-line interface for interacting with OpenAI's API,
+including chat completion, image generation, and command generation features.
+"""
+
+from .main import main
+
+# Import cleanup module to register automatic uninstall cleanup
+from . import cleanup
+
+# Import version from pyproject.toml to avoid duplication
+try:
+    import importlib.metadata as metadata
+
+    __version__ = metadata.version("gpt-shell-4o-mini")
+except ImportError:
+    # Fallback for older Python versions
+    import pkg_resources
+
+    __version__ = pkg_resources.get_distribution("gpt-shell-4o-mini").version
+
+__all__ = ["main"]

chatgpt/__main__.py

@@ -0,0 +1,8 @@
+"""
+Main entry point for python -m chatgpt execution.
+"""
+
+from chatgpt.main import main
+
+if __name__ == "__main__":
+    main()

chatgpt/api_client.py

@@ -0,0 +1,244 @@
+"""
+API client functions for GPT-shell-4o-mini.
+
+This module handles all interactions with the OpenAI API,
+including chat completions, image generation, and model management.
+"""
+
+import sys
+import json
+import webbrowser
+from datetime import datetime
+from rich.console import Console
+
+# Try importing necessary libraries and provide helpful error messages
+try:
+    from openai import OpenAI, APIError, RateLimitError, APIConnectionError
+except ImportError:
+    print(
+        "Error: 'openai' library not found. Please install it: pip install openai",
+        file=sys.stderr,
+    )
+    sys.exit(1)
+
+# Configuration
+DEFAULT_MODEL = "gpt-4o-mini"
+DEFAULT_TEMPERATURE = 0.7
+DEFAULT_MAX_TOKENS = 1024
+DEFAULT_IMAGE_SIZE = "1024x1024"
+MAX_CONTEXT_MESSAGES = 10
+
+console = Console()
+client = None  # Initialize client later after checking API key
+
+
+def handle_api_error(e):
+    """Handles common OpenAI API errors."""
+    if isinstance(e, RateLimitError):
+        console.print(
+            f"[bold red]API Error:[/bold red] Rate limit exceeded. Please check your plan and usage limits."
+        )
+    elif isinstance(e, APIConnectionError):
+        console.print(
+            f"[bold red]API Error:[/bold red] Could not connect to OpenAI. Check your network connection."
+        )
+    elif isinstance(e, APIError):
+        console.print(f"[bold red]API Error ({e.status_code}):[/bold red] {e.message}")
+        if e.body and "message" in e.body:
+            console.print(f"  Details: {e.body['message']}")
+    else:
+        console.print(f"[bold red]An unexpected error occurred:[/bold red] {e}")
+    sys.exit(1)
+
+
+def initialize_client(api_key):
+    """Initialize the OpenAI client with the provided API key."""
+    global client
+    try:
+        client = OpenAI(api_key=api_key)
+        return client
+    except Exception as e:
+        console.print(f"[bold red]Error initializing OpenAI client:[/bold red] {e}")
+        sys.exit(1)
+
+
+def list_models():
+    """Lists available OpenAI models."""
+    try:
+        console.print("[grey50]Fetching models...[/grey50]", end="\r")
+        models = client.models.list()
+        console.print(
+            "Available OpenAI Models:" + " " * 20
+        )  # Overwrite fetching message
+        # Sort models by creation date or ID if needed
+        for model in sorted(models.data, key=lambda x: x.id):
+            created_date = (
+                datetime.fromtimestamp(model.created).strftime("%Y-%m-%d")
+                if model.created
+                else "N/A"
+            )
+            console.print(
+                f"- [bold cyan]{model.id}[/bold cyan] (Owned by: {model.owned_by}, Created: {created_date})"
+            )
+    except APIError as e:
+        handle_api_error(e)
+
+
+def get_model_details(model_id):
+    """Gets details for a specific model."""
+    try:
+        console.print(f"[grey50]Fetching details for {model_id}...[/grey50]", end="\r")
+        model = client.models.retrieve(model_id)
+        console.print(
+            f"Details for model [bold cyan]{model_id}[/bold cyan]:" + " " * 20
+        )  # Overwrite
+        # Print details using rich formatting or just json.dumps
+        console.print(json.dumps(model.to_dict(), indent=2))
+    except APIError as e:
+        # Customize error for not found
+        if hasattr(e, "status_code") and e.status_code == 404:
+            console.print(f"[bold red]Error:[/bold red] Model '{model_id}' not found.")
+            sys.exit(1)
+        else:
+            handle_api_error(e)
+
+
+def generate_image(prompt, size):
+    """Generates an image using DALL-E."""
+    try:
+        console.print("[grey50]Generating image...[/grey50]", end="\r")
+        response = client.images.generate(
+            model="dall-e-3",  # Or dall-e-2 if preferred/available
+            prompt=prompt,
+            size=size,
+            quality="standard",  # or "hd"
+            n=1,
+        )
+        image_url = response.data[0].url
+        console.print("Image generated successfully!" + " " * 20)  # Overwrite
+        console.print(f"Link: {image_url}")
+
+        # Offer to open in browser
+        try:
+            if console.input("Open image in browser? (y/N) ").lower() == "y":
+                webbrowser.open(image_url)
+        except Exception as e:
+            console.print(f"[yellow]Could not open browser:[/yellow] {e}")
+
+    except APIError as e:
+        handle_api_error(e)
+    except (
+        Exception
+    ) as e:  # Catch other potential errors like network issues during download etc.
+        console.print(
+            f"[red]An error occurred during image generation or display:[/red] {e}"
+        )
+
+
+def get_chat_completion(messages, model, temperature, max_tokens):
+    """Gets a completion from a chat model."""
+    try:
+        # Import here to avoid circular imports
+        from .user_profile import format_user_profile
+        from .terminal_context import format_terminal_session
+
+        # Build complete context for EVERY prompt
+        context_parts = []
+
+        # Add static profile
+        profile = format_user_profile()
+        if profile:
+            context_parts.append(profile)
+
+        # Add terminal session
+        terminal = format_terminal_session()
+        if terminal:
+            context_parts.append(terminal)
+
+        # Combine contexts
+        full_context = "\n".join(context_parts)
+
+        # Prepend context to EVERY user message, not just the first one
+        for i, msg in enumerate(messages):
+            if msg["role"] == "user":
+                messages[i]["content"] = f"{full_context}\n\n{msg['content']}"
+
+        response = client.chat.completions.create(
+            model=model,
+            messages=messages,
+            temperature=temperature,
+            max_tokens=max_tokens,
+        )
+        content = response.choices[0].message.content
+        return content.strip() if content else ""
+    except APIError as e:
+        handle_api_error(e)
+        return None  # Indicate failure
+
+
+def get_system_prompt():
+    """Get the system prompt from custom file or default."""
+    from pathlib import Path
+
+    custom_prompt_file = Path.home() / ".chatgpt_py_sys_prompt"
+
+    if custom_prompt_file.exists():
+        try:
+            with open(custom_prompt_file, "r", encoding="utf-8") as f:
+                custom_prompt = f.read().strip()
+                if custom_prompt:
+                    return custom_prompt
+        except (IOError, OSError):
+            # If file exists but can't be read, fall back to default
+            pass
+
+    # Default system prompt
+    return """think carefully and provide a detailed response. use my prevoius data for a better answer."""
+
+
+# Command generation prompt
+COMMAND_GENERATION_PROMPT = "You are a Command Line Interface expert and your task is to provide functioning shell commands. Return a CLI command and nothing else - do not send it in a code block, quotes, or anything else, just the pure text CONTAINING ONLY THE COMMAND. If possible, return a one-line bash command or chain many commands together. Return ONLY the command ready to run in the terminal. The command should do the following:"
+
+
+def set_custom_system_prompt(prompt_text):
+    """Save a custom system prompt to the file."""
+    from pathlib import Path
+
+    custom_prompt_file = Path.home() / ".chatgpt_py_sys_prompt"
+
+    try:
+        with open(custom_prompt_file, "w", encoding="utf-8") as f:
+            f.write(prompt_text.strip())
+        return True
+    except (IOError, OSError):
+        return False
+
+
+def get_custom_system_prompt():
+    """Get the current custom system prompt from file."""
+    from pathlib import Path
+
+    custom_prompt_file = Path.home() / ".chatgpt_py_sys_prompt"
+
+    if custom_prompt_file.exists():
+        try:
+            with open(custom_prompt_file, "r", encoding="utf-8") as f:
+                return f.read().strip()
+        except (IOError, OSError):
+            pass
+
+    return None
+
+
+def reset_system_prompt():
+    """Remove the custom system prompt file to use default."""
+    from pathlib import Path
+
+    custom_prompt_file = Path.home() / ".chatgpt_py_sys_prompt"
+
+    try:
+        if custom_prompt_file.exists():
+            custom_prompt_file.unlink()
+        return True
+    except (IOError, OSError):
+        return False

chatgpt/checks.py

@@ -0,0 +1,211 @@
+"""
+Initial checks and setup functions for GPT-shell-4o-mini.
+
+This module handles API key verification, first-time setup wizard,
+and environment variable configuration.
+"""
+
+import os
+import sys
+import subprocess
+import json
+import requests
+from pathlib import Path
+from rich.console import Console
+
+# Configuration
+API_KEY = os.getenv("OPENAI_API_KEY") or os.getenv("OPENAI_KEY")
+USER_PROFILE_FILE = Path.home() / ".chatgpt_py_info"
+
+console = Console()
+
+
+def verify_api_key(api_key):
+    """Verify that an OpenAI API key is valid by making a test request."""
+    try:
+        response = requests.get(
+            "https://api.openai.com/v1/models",
+            headers={"Authorization": f"Bearer {api_key}"},
+            timeout=10,
+        )
+
+        # Check if request was successful
+        if response.status_code == 200:
+            data = response.json()
+            if "data" in data:
+                return True
+        return False
+    except Exception:
+        return False
+
+
+def update_shell_profile(api_key):
+    """Add or update the OPENAI_KEY in the user's shell profile or system."""
+    import platform
+
+    system = platform.system()
+
+    if system == "Windows":
+        # Windows: Use setx to set user environment variable
+        try:
+            subprocess.run(
+                ["setx", "OPENAI_KEY", api_key], check=True, capture_output=True
+            )
+            # Also set for current session
+            os.environ["OPENAI_KEY"] = api_key
+            console.print(
+                f"[green]✓[/green] Added OPENAI_KEY to Windows environment variables"
+            )
+            console.print(
+                f"[yellow]Note:[/yellow] Restart your terminal for the change to take effect"
+            )
+            return True
+        except Exception as e:
+            console.print(
+                f"[yellow]Warning:[/yellow] Could not set environment variable: {e}"
+            )
+            console.print(
+                f"[yellow]Please manually set OPENAI_KEY in System Settings[/yellow]"
+            )
+            return False
+
+    else:  # macOS or Linux
+        # Existing Unix shell profile logic
+        profile_paths = [
+            Path.home() / ".bashrc",
+            Path.home() / ".zprofile",
+            Path.home() / ".zshrc",
+            Path.home() / ".bash_profile",
+            Path.home() / ".profile",
+        ]
+
+        for profile_path in profile_paths:
+            if profile_path.exists():
+                try:
+                    with profile_path.open("r") as f:
+                        content = f.read()
+
+                    if "export OPENAI_KEY" not in content:
+                        with profile_path.open("a") as f:
+                            f.write(f"\n# OpenAI API Key for GPT-shell-4o-mini\n")
+                            f.write(f"export OPENAI_KEY={api_key}\n")
+                        console.print(
+                            f"[green]✓[/green] Added OPENAI_KEY to {profile_path}"
+                        )
+                        return True
+                    else:
+                        console.print(
+                            f"[yellow]![/yellow] OPENAI_KEY already exists in {profile_path}"
+                        )
+                        return True
+                except Exception as e:
+                    console.print(
+                        f"[yellow]Warning:[/yellow] Could not update {profile_path}: {e}"
+                    )
+                    continue
+
+        # If no profile found
+        console.print("[yellow]Warning:[/yellow] No shell profile found.")
+        console.print(f"[yellow]Please manually add to your shell config:[/yellow]")
+        console.print(f"  export OPENAI_KEY={api_key}")
+        return False
+
+
+def first_run_setup():
+    """Interactive setup wizard for first-time users."""
+    console.print("\n" + "=" * 60)
+    console.print("[bold cyan]Welcome to GPT-shell-4o-mini![/bold cyan]")
+    console.print("=" * 60)
+    console.print("\nIt looks like you haven't set up your OpenAI API key yet.")
+    console.print("\n[bold]Where to get an API key:[/bold]")
+    console.print("  https://platform.openai.com/account/api-keys")
+    console.print("\n" + "=" * 60 + "\n")
+
+    try:
+        user_input = (
+            console.input("[bold]Do you have an OpenAI API key? (yes/no):[/bold] ")
+            .strip()
+            .lower()
+        )
+
+        if user_input not in ["yes", "y"]:
+            console.print("\n[yellow]Please get an API key from:[/yellow]")
+            console.print("  https://platform.openai.com/account/api-keys")
+            console.print(
+                "\n[cyan]After getting your key, run 'gpt' again to set it up.[/cyan]\n"
+            )
+            sys.exit(0)
+
+        api_key = console.input("\n[bold]Enter your OpenAI API key:[/bold] ").strip()
+
+        if not api_key:
+            console.print("[red]Error:[/red] No API key provided.")
+            sys.exit(1)
+
+        console.print("\n[cyan]Verifying API key...[/cyan]")
+
+        if not verify_api_key(api_key):
+            console.print("[red]Error:[/red] Invalid API key or unable to verify.")
+            console.print("Please check your key and try again.\n")
+            sys.exit(1)
+
+        console.print("[green]✓[/green] API key verified successfully!")
+
+        # Update shell profile
+        console.print("\n[cyan]Saving API key to your shell profile...[/cyan]")
+        profile_saved = update_shell_profile(api_key)
+
+        # Import here to avoid circular imports
+        from .user_profile import collect_user_profile, save_user_profile
+
+        # Collect and save user profile
+        console.print("\n[cyan]Setting up your profile...[/cyan]")
+        profile = collect_user_profile()
+
+        # Allow username customization
+        console.print(f"\n[bold]Detected username:[/bold] {profile['username']}")
+        custom_name = console.input(
+            "[bold]Press Enter to use this, or type a different name:[/bold] "
+        ).strip()
+
+        if custom_name:
+            profile["username"] = custom_name
+
+        # Save profile
+        if save_user_profile(profile):
+            console.print(f"\n[green]✓[/green] Profile saved:")
+            console.print(f"  Username: {profile['username']}")
+            console.print(f"  OS: {profile['os']}")
+            if "distro" in profile:
+                console.print(f"  Distribution: {profile['distro']}")
+
+        if profile_saved:
+            console.print("\n[green]✓[/green] Setup complete!")
+            console.print("\n[bold]Important:[/bold] For the key to be available, run:")
+            console.print(
+                "  [cyan]source ~/.bashrc[/cyan]  (or your shell's config file)"
+            )
+            console.print(
+                "\nOr restart your terminal, then run '[cyan]gpt[/cyan]' again.\n"
+            )
+        else:
+            console.print(
+                "\n[yellow]Setup complete, but you'll need to manually add the key.[/yellow]\n"
+            )
+
+        sys.exit(0)
+
+    except (EOFError, KeyboardInterrupt):
+        console.print("\n\n[yellow]Setup cancelled.[/yellow]\n")
+        sys.exit(0)
+
+
+def check_api_key():
+    """Check if API key is available, run setup if not."""
+    global API_KEY
+    if not API_KEY:
+        # Run first-time setup wizard
+        first_run_setup()
+        # If we get here, setup was cancelled or failed
+        sys.exit(1)
+    return API_KEY

chatgpt/cleanup.py

@@ -0,0 +1,143 @@
+"""
+Automatic cleanup module for GPT-shell-4o-mini.
+
+This module registers an atexit handler that detects when the package
+is being uninstalled and automatically cleans up all files and environment variables.
+"""
+
+import os
+import sys
+import subprocess
+import platform
+import atexit
+from pathlib import Path
+from rich.console import Console
+
+console = Console()
+
+# Files created by the package
+FILES_TO_REMOVE = [
+    "~/.chatgpt_py_info",  # User profile
+    "~/.chatgpt_py_history",  # Chat history
+    "~/.chatgpt_py_sys_prompt",  # Custom system prompt
+]
+
+# Shell profiles that might contain OPENAI_KEY
+SHELL_PROFILES = [
+    "~/.bashrc",
+    "~/.zprofile",
+    "~/.zshrc",
+    "~/.bash_profile",
+    "~/.profile",
+]
+
+
+def remove_file(file_path):
+    """Remove a single file if it exists."""
+    path = Path(file_path).expanduser()
+    if path.exists():
+        try:
+            path.unlink()
+            return True
+        except Exception:
+            return False
+    return False
+
+
+def remove_openai_key_from_profiles():
+    """Remove OPENAI_KEY from shell profile files."""
+    system = platform.system()
+
+    if system == "Windows":
+        # Remove Windows environment variable
+        try:
+            result = subprocess.run(
+                ["reg", "delete", "HKCU\\Environment", "/v", "OPENAI_KEY", "/f"],
+                capture_output=True,
+                text=True,
+            )
+            return result.returncode == 0
+        except Exception:
+            return False
+    else:
+        # Unix-like systems - remove from shell profiles
+        key_removed = False
+        for profile_file in SHELL_PROFILES:
+            profile_path = Path(profile_file).expanduser()
+            if profile_path.exists():
+                try:
+                    with profile_path.open("r") as f:
+                        lines = f.readlines()
+
+                    # Filter out lines containing OPENAI_KEY for our package
+                    filtered_lines = []
+                    local_key_removed = False
+                    in_our_section = False
+
+                    for line in lines:
+                        if "# OpenAI API Key for GPT-shell-4o-mini" in line:
+                            in_our_section = True
+                            local_key_removed = True
+                            continue
+                        elif in_our_section and line.strip().startswith(
+                            "export OPENAI_KEY="
+                        ):
+                            continue  # Skip the export line
+                        elif in_our_section and line.strip() == "":
+                            in_our_section = False  # End of our section
+                            continue
+                        elif in_our_section:
+                            continue  # Skip any other lines in our section
+
+                        filtered_lines.append(line)
+
+                    if local_key_removed:
+                        with profile_path.open("w") as f:
+                            f.writelines(filtered_lines)
+                        key_removed = True
+
+                except Exception:
+                    continue
+
+        return key_removed
+
+
+def cleanup_on_uninstall():
+    """Cleanup function called during package uninstall."""
+    # Only run if we're being uninstalled (not on normal exit)
+    if not hasattr(sys, "real_prefix") and not (
+        hasattr(sys, "base_prefix") and sys.base_prefix != sys.prefix
+    ):
+        # Check if the package directory still exists
+        package_dir = Path(__file__).parent.parent
+        if not package_dir.exists():
+            # Package is being uninstalled, run cleanup
+            try:
+                # Remove configuration files
+                files_removed = 0
+                for file_path in FILES_TO_REMOVE:
+                    if remove_file(file_path):
+                        files_removed += 1
+
+                # Remove environment variables
+                remove_openai_key_from_profiles()
+
+                # Print cleanup message (only if we can)
+                try:
+                    console.print(
+                        f"\n[cyan]GPT-shell-4o-mini cleanup: Removed {files_removed} config files[/cyan]"
+                    )
+                except:
+                    pass  # Silent fail if console not available
+
+            except Exception:
+                pass  # Silent fail on any errors
+
+
+def register_cleanup():
+    """Register the cleanup function to run on package uninstall."""
+    atexit.register(cleanup_on_uninstall)
+
+
+# Register cleanup when module is imported
+register_cleanup()