cmdgen-ai-cli 0.1.0__py3-none-any.whl

cmdgen/__init__.py

@@ -0,0 +1,5 @@
+"""
+cmdgen - AI-powered CLI tool to translate natural language into terminal commands
+"""
+
+__version__ = "0.1.0"

cmdgen/__main__.py

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

cmdgen/config.py

@@ -0,0 +1,43 @@
+"""
+cmdgen/config.py
+
+Purpose:
+This file is responsible for managing the user's settings. It defines what the 
+configuration looks like (using `pydantic`), and handles safely loading and 
+saving the API keys to a local file on the user's hard drive (`~/.config/cmdgen/config.json`).
+"""
+import os
+import json
+from pathlib import Path
+from pydantic import BaseModel, Field
+
+CONFIG_DIR = Path.home() / ".config" / "cmdgen"
+CONFIG_FILE = CONFIG_DIR / "config.json"
+
+class AppConfig(BaseModel):
+    provider: str = Field(default="gemini", description="The LLM provider to use")
+    api_key: str = Field(default="", description="The API key for the provider")
+
+def load_config() -> AppConfig:
+    """Loads the configuration from disk, or returns default if not found."""
+    if not CONFIG_FILE.exists():
+        return AppConfig()
+    try:
+        with open(CONFIG_FILE, "r") as f:
+            data = json.load(f)
+            return AppConfig(**data)
+    except Exception:
+        # In case of corruption, return default
+        return AppConfig()
+
+def save_config(config: AppConfig) -> None:
+    """Saves the configuration to disk securely."""
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    with open(CONFIG_FILE, "w") as f:
+        json.dump(config.model_dump(), f, indent=4)
+    
+    # Ensure strict permissions on Windows/Linux if possible
+    try:
+        os.chmod(CONFIG_FILE, 0o600)
+    except Exception:
+        pass  # Permissions might act differently on Windows

cmdgen/context.py

@@ -0,0 +1,32 @@
+"""
+cmdgen/context.py
+
+Purpose:
+This file gathers information about the environment where the user is running the tool.
+It detects the Operating System, the shell (e.g. bash, powershell), and the current 
+working directory so that the AI can generate commands tailored perfectly to their system.
+"""
+import os
+import platform
+
+def get_os_name() -> str:
+    """Returns the name of the operating system."""
+    return platform.system() + " " + platform.release()
+
+def get_shell_name() -> str:
+    """Attempts to determine the current shell running the tool."""
+    # On Windows, COMSPEC is usually set to cmd.exe or powershell.exe
+    # On Unix, SHELL is usually set to /bin/bash, /bin/zsh, etc.
+    shell = os.environ.get("SHELL")
+    if shell:
+        return shell.split(os.sep)[-1]
+    
+    comspec = os.environ.get("COMSPEC")
+    if comspec:
+        return comspec.split(os.sep)[-1]
+        
+    return "unknown"
+
+def get_cwd() -> str:
+    """Returns the current working directory."""
+    return os.getcwd()

cmdgen/executor.py

@@ -0,0 +1,59 @@
+"""
+cmdgen/executor.py
+
+Purpose:
+This file handles the interactive prompt and execution of the final command.
+It uses `prompt_toolkit` to allow the user to edit the generated command 
+before running it, and `subprocess` to actually run the command on the OS.
+"""
+import subprocess
+import sys
+from rich.console import Console
+from prompt_toolkit import PromptSession
+from prompt_toolkit.lexers import PygmentsLexer
+from pygments.lexers.shell import BashLexer
+
+console = Console()
+
+DANGEROUS_KEYWORDS = [
+    "rm ", "del ", "format ", "drop ", "mkfs", "truncate"
+]
+
+def check_safety(command: str) -> None:
+    """Checks if a command contains potentially dangerous keywords."""
+    cmd_lower = command.lower()
+    if any(keyword in cmd_lower for keyword in DANGEROUS_KEYWORDS):
+        console.print("[bold yellow][WARNING] This command may be destructive! Please review carefully.[/bold yellow]")
+
+def execute_interactive(command: str) -> None:
+    """
+    Presents the generated command to the user for editing and executes it.
+    """
+    check_safety(command)
+    
+    session = PromptSession()
+    try:
+        # Prompt the user, pre-filled with the AI's command
+        final_command = session.prompt(
+            "> ", 
+            default=command,
+            lexer=PygmentsLexer(BashLexer)
+        )
+        
+        final_command = final_command.strip()
+        if not final_command:
+            console.print("[dim]Command cancelled.[/dim]")
+            return
+
+        # Execute natively
+        console.print()
+        subprocess.run(final_command, shell=True)
+        
+    except KeyboardInterrupt:
+        # User pressed Ctrl+C
+        console.print("\n[dim]Command cancelled by user.[/dim]")
+    except EOFError:
+        # User pressed Ctrl+D
+        console.print("\n[dim]Command cancelled by user.[/dim]")
+    except Exception as e:
+        console.print(f"[bold red]Failed to execute command:[/bold red] {e}")

cmdgen/llm/__init__.py

@@ -0,0 +1,3 @@
+"""
+cmdgen LLM providers module.
+"""

cmdgen/llm/base.py

@@ -0,0 +1,37 @@
+"""
+cmdgen/llm/base.py
+
+Purpose:
+This file defines the `LLMProvider` abstract base class. It serves as a blueprint or 
+"contract". It guarantees that no matter what AI provider we add in the future (Gemini, 
+OpenAI, Claude, etc.), they will all have a `generate_command()` method with the same inputs.
+"""
+from abc import ABC, abstractmethod
+from typing import Dict, Any
+
+class LLMProvider(ABC):
+    """Abstract base class for all LLM providers."""
+
+    @abstractmethod
+    def generate_command(
+        self, 
+        query: str, 
+        os_name: str, 
+        shell_name: str, 
+        cwd: str, 
+        api_key: str
+    ) -> tuple[str, str]:
+        """
+        Generate a terminal command based on a natural language query.
+        
+        Args:
+            query: The user's natural language request.
+            os_name: The operating system (e.g., Windows, Linux).
+            shell_name: The shell being used (e.g., powershell, bash).
+            cwd: The current working directory.
+            api_key: The API key for the provider.
+            
+        Returns:
+            A tuple of (generated_command, explanation).
+        """
+        pass

cmdgen/llm/gemini.py

@@ -0,0 +1,66 @@
+"""
+cmdgen/llm/gemini.py
+
+Purpose:
+This file contains the actual implementation for the Google Gemini AI. It takes the 
+user's query and their system context, constructs the hidden system prompt (with 
+safety filters), and calls the `google-genai` API to get the command back.
+"""
+from google import genai
+from google.genai import types
+
+from cmdgen.llm.base import LLMProvider
+
+class GeminiProvider(LLMProvider):
+    """Gemini implementation of the LLM Provider."""
+
+    def generate_command(
+        self, 
+        query: str, 
+        os_name: str, 
+        shell_name: str, 
+        cwd: str, 
+        api_key: str
+    ) -> tuple[str, str]:
+        
+        # Initialize the new SDK client
+        client = genai.Client(api_key=api_key)
+
+        # Use gemini-2.5-flash, the fast model
+        model_name = 'gemini-2.5-flash'
+
+        system_prompt = (
+            "You are an expert systems administrator CLI assistant.\n"
+            "Your job is to translate the user's natural language request into a valid, safe terminal command.\n\n"
+            f"CONTEXT:\n"
+            f"- OS: {os_name}\n"
+            f"- Shell: {shell_name}\n"
+            f"- Current Working Directory: {cwd}\n\n"
+            "RULES:\n"
+            "1. Output ONLY the raw command on the first line.\n"
+            "2. Output a brief, 1-sentence explanation on the second line.\n"
+            "3. Do not use markdown blocks (```) or quotes around the command.\n"
+            "4. Ensure paths are compatible with the specified OS."
+        )
+
+        prompt = f"{system_prompt}\n\nUSER REQUEST: {query}\n\nCOMMAND AND EXPLANATION:"
+
+        try:
+            response = client.models.generate_content(
+                model=model_name,
+                contents=prompt,
+                config=types.GenerateContentConfig(
+                    temperature=0.1 # Low temp for deterministic output
+                )
+            )
+            
+            text = response.text.strip()
+            lines = text.split('\n', 1)
+            
+            command = lines[0].strip()
+            explanation = lines[1].strip() if len(lines) > 1 else "No explanation provided."
+            
+            return command, explanation
+
+        except Exception as e:
+            raise RuntimeError(f"Gemini API Error: {str(e)}")

cmdgen/main.py

@@ -0,0 +1,104 @@
+"""
+cmdgen/main.py
+
+Purpose:
+This is the primary entry point for the CLI application. It uses the `typer` library 
+to define all the commands the user can run (like `cmdgen "query"` and `cmdgen config`).
+It connects the user's input to the configuration, context, and AI logic.
+"""
+import typer
+from rich.console import Console
+from rich.panel import Panel
+from rich.text import Text
+
+from cmdgen.config import load_config, save_config
+
+app = typer.Typer(help="AI-powered terminal command generator.")
+config_app = typer.Typer(help="Manage configuration (e.g. API keys).")
+app.add_typer(config_app, name="config")
+
+console = Console()
+
+@app.command()
+def generate(
+    query: list[str] = typer.Argument(..., help="The natural language query to translate into a command")
+):
+    """
+    Generate and execute a terminal command from natural language.
+    """
+    query_str = " ".join(query)
+    config = load_config()
+    if not config.api_key:
+        console.print(Panel(
+            "[bold red]API Key Missing[/bold red]\n\n"
+            "To use cmdgen, you need to set up your free Gemini API key.\n"
+            "1. Get your key here: [link]https://aistudio.google.com/app/apikey[/link]\n"
+            "2. Set it by running: [bold cyan]cmdgen config set --provider gemini --api-key \"YOUR_KEY\"[/bold cyan]",
+            title="Setup Required", expand=False
+        ))
+        raise typer.Exit(code=1)
+
+    # Check for new updates silently
+    from cmdgen.update import check_for_updates
+    check_for_updates()
+
+    with console.status(f"[bold green]Asking {config.provider}...", spinner="dots"):
+        from cmdgen.llm.gemini import GeminiProvider
+        from cmdgen.context import get_os_name, get_shell_name, get_cwd
+        
+        provider = GeminiProvider() # We can make this dynamic later if we add OpenAI
+        try:
+            command, explanation = provider.generate_command(
+                query=query_str,
+                os_name=get_os_name(),
+                shell_name=get_shell_name(),
+                cwd=get_cwd(),
+                api_key=config.api_key
+            )
+        except Exception as e:
+            console.print(f"[bold red]Error generating command:[/bold red] {e}")
+            raise typer.Exit(code=1)
+
+    console.print(f"\n[bold blue]Explanation:[/bold blue] {explanation}")
+    console.print("[dim]---[/dim]")
+    
+    from cmdgen.executor import execute_interactive
+    execute_interactive(command)
+
+@config_app.command("set")
+def config_set(
+    provider: str = typer.Option("gemini", help="The LLM provider (e.g., gemini, openai)"),
+    api_key: str = typer.Option(..., help="The API key for the provider")
+):
+    """
+    Set the configuration values.
+    """
+    config = load_config()
+    config.provider = provider
+    config.api_key = api_key
+    save_config(config)
+    console.print(f"[green]✔[/green] Configuration saved successfully! Provider set to [bold]{provider}[/bold].")
+
+@config_app.command("view")
+def config_view():
+    """
+    View the current configuration safely.
+    """
+    config = load_config()
+    masked_key = f"{config.api_key[:4]}...{config.api_key[-4:]}" if len(config.api_key) > 8 else "***"
+    
+    console.print(Panel(
+        f"[bold]Provider:[/bold] {config.provider}\n"
+        f"[bold]API Key:[/bold] {masked_key}",
+        title="Current Configuration", expand=False
+    ))
+
+def cli_main():
+    import sys
+    # If the first argument is not a known subcommand or flag, default to "generate"
+    if len(sys.argv) > 1 and sys.argv[1] not in ["config", "generate", "--help", "-h", "--version"]:
+        sys.argv.insert(1, "generate")
+    app()
+
+if __name__ == "__main__":
+    cli_main()

cmdgen/update.py

@@ -0,0 +1,63 @@
+"""
+Purpose: Checks PyPI for a newer version of cmdgen and notifies the user.
+Caches the check to avoid slowing down the CLI on every run.
+"""
+import urllib.request
+import json
+import time
+from rich.console import Console
+
+from cmdgen.config import CONFIG_DIR
+
+console = Console()
+
+# We cache the update check in the config directory
+UPDATE_CACHE_FILE = CONFIG_DIR / "update_check.json"
+CACHE_TTL = 86400  # 24 hours in seconds
+PACKAGE_NAME = "cmdgen"
+
+# Fallback version for development
+def get_current_version() -> str:
+    try:
+        from importlib.metadata import version, PackageNotFoundError
+        return version(PACKAGE_NAME)
+    except (ImportError, Exception):
+        return "0.1.0"
+
+def check_for_updates() -> None:
+    """Silently checks PyPI for updates, at most once per day."""
+    now = time.time()
+    
+    # Check cache
+    if UPDATE_CACHE_FILE.exists():
+        try:
+            cache_data = json.loads(UPDATE_CACHE_FILE.read_text(encoding="utf-8"))
+            if now - cache_data.get("last_check", 0) < CACHE_TTL:
+                return # Skip check, too soon
+        except Exception:
+            pass # If cache is corrupted, ignore it
+
+    try:
+        # Fetch latest version from PyPI
+        req = urllib.request.Request(
+            f"https://pypi.org/pypi/{PACKAGE_NAME}/json",
+            headers={"User-Agent": f"cmdgen/{get_current_version()}"}
+        )
+        with urllib.request.urlopen(req, timeout=1.5) as response:
+            data = json.loads(response.read().decode("utf-8"))
+            latest_version = data["info"]["version"]
+            
+        current = get_current_version()
+        
+        # Simple string comparison (this works well enough for simple semver like 0.1.0 vs 0.2.0)
+        # We don't want to add a `packaging` dependency just for this.
+        if latest_version and latest_version != current:
+            console.print(f"[bold yellow]💡 A new version of cmdgen ({latest_version}) is available! Run `pipx upgrade cmdgen` to update.[/bold yellow]")
+            
+        # Update cache
+        UPDATE_CACHE_FILE.parent.mkdir(parents=True, exist_ok=True)
+        UPDATE_CACHE_FILE.write_text(json.dumps({"last_check": now, "latest_version": latest_version}), encoding="utf-8")
+        
+    except Exception:
+        # If offline or PyPI is down, silently fail. We don't want to bother the user.
+        pass

cmdgen_ai_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,66 @@
+Metadata-Version: 2.4
+Name: cmdgen-ai-cli
+Version: 0.1.0
+Summary: AI-powered CLI tool to translate natural language into terminal commands
+Requires-Python: >=3.9
+Requires-Dist: google-genai>=0.1.0
+Requires-Dist: prompt-toolkit>=3.0.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: typer>=0.9.0
+Provides-Extra: dev
+Requires-Dist: black>=23.0; extra == 'dev'
+Requires-Dist: flake8>=6.0; extra == 'dev'
+Requires-Dist: pytest>=7.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# cmdgen 🪄
+
+An AI-powered CLI tool that translates your natural language into native terminal commands and lets you review them before execution. Powered by Google's Gemini API.
+
+## Features
+
+- **Natural Language to CLI:** Just type what you want to do.
+- **Context-Aware:** Knows your OS (Windows/Linux/macOS), Shell, and Working Directory for perfect commands.
+- **Interactive Execution:** Uses `prompt_toolkit` to let you tweak the AI's generated command before running it.
+- **Safety First:** Warns you with bold yellow text if the command looks destructive (e.g., `rm`, `del`, `format`).
+- **Auto-Updater:** Silently checks for updates so you're always running the best version.
+
+## Installation
+
+The recommended way to install Python CLI tools globally is using `pipx`:
+
+```bash
+pipx install cmdgen
+```
+
+*(Alternatively, you can `pip install cmdgen` in a virtual environment)*
+
+## Quick Start
+
+1. **Get an API Key:** Get a free Gemini API key from [Google AI Studio](https://aistudio.google.com/app/apikey).
+2. **Configure your Key:**
+   ```bash
+   cmdgen config set --provider gemini --api-key "YOUR_API_KEY"
+   ```
+3. **Use the Tool:**
+   ```bash
+   cmdgen "find all python files larger than 10MB in the current directory"
+   ```
+
+You will see an explanation of the command, and an interactive prompt where you can edit it or just press `Enter` to run it!
+
+## Configuration
+
+View your current configuration (safely masked):
+```bash
+cmdgen config view
+```
+
+## Contributing
+1. Clone the repository
+2. Install dependencies: `pip install -e .[dev]`
+3. Run tests: `pytest`
+
+## License
+MIT

cmdgen_ai_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+cmdgen/__init__.py,sha256=wxV1u5iTty9coWhQsiy0VJwtoTDw8WIT-sFG_NZEq4U,113
+cmdgen/__main__.py,sha256=P1upHqRqbajqAI8HNwvOfMmB1jB3Mw3yUYdExBqWvjc,66
+cmdgen/config.py,sha256=HbREfGwP1ucmBFuGGlQtIa2F52W_noN8WJVM-_mIJ7E,1475
+cmdgen/context.py,sha256=Vth2O-HBVWENt3nexJ5I7a3AsIP6hQEQBQ66-7_jvfo,1010
+cmdgen/executor.py,sha256=5Yyxgas1DHgwkQE5aDBrLvIF2efjIGSU2EJe51eTQkc,1926
+cmdgen/main.py,sha256=k1on3afYzdhlaGitd4voYTKHG3cT9CTfonB6efjRqxw,3674
+cmdgen/update.py,sha256=PXN1OTpgL-7v6O5gHSDoY35EPd6jlb9TmyKiSBozTns,2374
+cmdgen/llm/__init__.py,sha256=R-z_OJVCsRBWzQf3PNgM677ZzX-RtA0ikM-t8WgrdYY,37
+cmdgen/llm/base.py,sha256=gm1QGmLqUt1zw7WUgSBmRFmeX3q663sOuR9XVsxAom8,1157
+cmdgen/llm/gemini.py,sha256=aIyIBQoav_-48-ZPkldeV1ytiv8QLHVWndY6Ta01kpQ,2290
+cmdgen_ai_cli-0.1.0.dist-info/METADATA,sha256=0y1JIjejXKrApfnAi27jJNlhSniveM7BV0VWsr9tEF4,2106
+cmdgen_ai_cli-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+cmdgen_ai_cli-0.1.0.dist-info/entry_points.txt,sha256=Rv5gneL6LCvI_D9mX5oAM_1UCtpl2X-PIfiyUbtkLg0,74
+cmdgen_ai_cli-0.1.0.dist-info/RECORD,,

cmdgen_ai_cli-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

cmdgen_ai_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+cg = cmdgen.main:cli_main
+cmdgen = cmdgen.main:cli_main