terminal-sherpa 0.1.0__py3-none-any.whl

ask/config.py

@@ -0,0 +1,94 @@
+"""Configuration loading and management module."""
+
+import os
+from pathlib import Path
+from typing import Any
+
+import toml
+
+from ask.exceptions import ConfigurationError
+
+SYSTEM_PROMPT = (
+    "You are a bash command generator. Given a user request, "
+    "respond with ONLY the bash command that accomplishes the task. "
+    "Do not include explanations, comments, or any other text. "
+    "Just the command.",
+)
+
+
+def get_config_path() -> Path | None:
+    """Find config file using XDG standard."""
+    # Primary location: $XDG_CONFIG_HOME/ask/config.toml
+    xdg_config_home = os.environ.get("XDG_CONFIG_HOME")
+    if xdg_config_home:
+        primary_path = Path(xdg_config_home) / "ask" / "config.toml"
+    else:
+        primary_path = Path.home() / ".config" / "ask" / "config.toml"
+
+    if primary_path.exists():
+        return primary_path
+
+    # Fallback location: ~/.ask/config.toml
+    fallback_path = Path.home() / ".ask" / "config.toml"
+    if fallback_path.exists():
+        return fallback_path
+
+    return None
+
+
+def load_config() -> dict[str, Any]:
+    """Load configuration from TOML file."""
+    config_path = get_config_path()
+
+    if config_path is None:
+        return {}
+
+    try:
+        with open(config_path) as f:
+            return toml.load(f)
+    except Exception as e:
+        raise ConfigurationError(f"Failed to load config file {config_path}: {e}")
+
+
+def get_provider_config(
+    config: dict[str, Any], provider_spec: str
+) -> tuple[str, dict[str, Any]]:
+    """Parse provider:model syntax and return provider name and config."""
+    if ":" in provider_spec:
+        provider_name, model_name = provider_spec.split(":", 1)
+
+        # First try to get nested config (e.g., anthropic.haiku)
+        provider_section = config.get(provider_name, {})
+        if isinstance(provider_section, dict) and model_name in provider_section:
+            provider_config = provider_section[model_name]
+        else:
+            # Fall back to base provider config
+            provider_config = provider_section
+    else:
+        provider_name = provider_spec
+        provider_config = config.get(provider_name, {})
+
+    # Add global settings
+    global_config = config.get("ask", {})
+
+    # Merge global and provider-specific config
+    merged_config = {**global_config, **provider_config}
+
+    return provider_name, merged_config
+
+
+def get_default_model(config: dict[str, Any]) -> str | None:
+    """Get default model from configuration."""
+    global_config = config.get("ask", {})
+    return global_config.get("default_model")
+
+
+def get_default_provider() -> str | None:
+    """Determine fallback provider from environment variables."""
+    # Check for API keys in order of preference: claude -> openai
+    if os.environ.get("ANTHROPIC_API_KEY"):
+        return "anthropic"
+    elif os.environ.get("OPENAI_API_KEY"):
+        return "openai"
+
+    return None

ask/exceptions.py

@@ -0,0 +1,25 @@
+"""Custom exception classes for the ask CLI tool."""
+
+
+class ConfigurationError(Exception):
+    """Raised when there are configuration-related errors."""
+
+    pass
+
+
+class AuthenticationError(Exception):
+    """Raised when authentication fails."""
+
+    pass
+
+
+class APIError(Exception):
+    """Raised when API requests fail."""
+
+    pass
+
+
+class RateLimitError(APIError):
+    """Raised when API rate limits are exceeded."""
+
+    pass

ask/main.py

@@ -0,0 +1,115 @@
+import argparse
+import sys
+from typing import Any
+
+from loguru import logger
+
+import ask.config as config
+import ask.providers as providers
+from ask.exceptions import APIError, AuthenticationError, ConfigurationError
+from ask.providers.base import ProviderInterface
+
+
+def configure_logging(verbose: bool) -> None:
+    """Configure loguru logging with appropriate level and format."""
+    logger.remove()  # Remove default handler
+
+    level = "DEBUG" if verbose else "ERROR"
+
+    logger.add(
+        sys.stderr,
+        format="{time:YYYY-MM-DD HH:mm:ss.SSS} | <level>{level}</level> | {message}",
+        level=level,
+        colorize=True,
+    )
+
+
+def parse_arguments() -> argparse.Namespace:
+    """Parse command line arguments."""
+    parser = argparse.ArgumentParser(description="AI-powered bash command generator")
+    parser.add_argument("prompt", help="Natural language description of the task")
+    parser.add_argument(
+        "--model", help="Provider and model to use (format: provider[:model])"
+    )
+    parser.add_argument(
+        "--verbose", "-v", action="store_true", help="Enable verbose logging"
+    )
+    return parser.parse_args()
+
+
+def load_configuration() -> dict[str, Any]:
+    """Load configuration from file and environment."""
+    try:
+        return config.load_config()
+    except ConfigurationError as e:
+        logger.error(f"Configuration error: {e}")
+        sys.exit(1)
+
+
+def resolve_provider(args, config_data) -> ProviderInterface:
+    """Determine which provider to use based on arguments and configuration.
+
+    Args:
+        args: Parsed command line arguments
+        config_data: Configuration data loaded from the config file
+
+    Returns:
+        Provider instance
+    """
+    if args.model:
+        logger.debug(f"Using model specified via --model argument: {args.model}")
+        provider_name, provider_config = config.get_provider_config(
+            config_data, args.model
+        )
+    else:
+        # Check for default model in config first
+        default_model = config.get_default_model(config_data)
+        if default_model:
+            logger.debug(f"Using default model from config: {default_model}")
+            provider_name, provider_config = config.get_provider_config(
+                config_data, default_model
+            )
+        else:
+            logger.warning(
+                "No default model configured, falling back to environment variables"
+            )
+            # Use default provider from environment variables
+            default_provider = config.get_default_provider()
+            if not default_provider:
+                logger.error(
+                    "No default model configured and no API keys found. "
+                    "Please set ANTHROPIC_API_KEY or OPENAI_API_KEY environment "
+                    "variable, or set a default_provider in your config file."
+                )
+                sys.exit(1)
+            logger.debug(f"Using default provider from environment: {default_provider}")
+            provider_name, provider_config = config.get_provider_config(
+                config_data, default_provider
+            )
+
+    try:
+        logger.debug(f"Initializing provider: {provider_name}")
+        return providers.get_provider(provider_name, provider_config)
+    except ConfigurationError as e:
+        logger.error(f"Error: {e}")
+        sys.exit(1)
+
+
+def main() -> None:
+    """Main entry point for the CLI application."""
+    args = parse_arguments()
+    configure_logging(args.verbose)
+    config_data = load_configuration()
+
+    try:
+        provider = resolve_provider(args, config_data)
+        provider.validate_config()
+        bash_command = provider.get_bash_command(args.prompt)
+        print(bash_command)
+    except (AuthenticationError, APIError) as e:
+        logger.error(str(e))
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

ask/providers/__init__.py

@@ -0,0 +1,35 @@
+"""Provider registry and initialization module."""
+
+from .anthropic import AnthropicProvider
+from .base import ProviderInterface
+from .openai import OpenAIProvider
+
+# Provider registry - maps provider names to their classes
+_PROVIDER_REGISTRY: dict[str, type[ProviderInterface]] = {}
+
+
+def register_provider(name: str, provider_class: type[ProviderInterface]) -> None:
+    """Register a provider class with the given name."""
+    _PROVIDER_REGISTRY[name] = provider_class
+
+
+def get_provider(name: str, config: dict) -> ProviderInterface:
+    """Get a provider instance by name."""
+    if name not in _PROVIDER_REGISTRY:
+        from ask.exceptions import ConfigurationError
+
+        raise ConfigurationError(
+            f"Provider '{name}' not found. Available providers: {list_providers()}"
+        )
+
+    provider_class = _PROVIDER_REGISTRY[name]
+    return provider_class(config)
+
+
+def list_providers() -> list[str]:
+    """List all available provider names."""
+    return list(_PROVIDER_REGISTRY.keys())
+
+
+register_provider("anthropic", AnthropicProvider)
+register_provider("openai", OpenAIProvider)

ask/providers/anthropic.py

@@ -0,0 +1,73 @@
+"""Anthropic provider implementation."""
+
+import os
+from typing import Any
+
+import anthropic
+
+from ask.config import SYSTEM_PROMPT
+from ask.exceptions import APIError, AuthenticationError, RateLimitError
+from ask.providers.base import ProviderInterface
+
+
+class AnthropicProvider(ProviderInterface):
+    """Anthropic AI provider implementation."""
+
+    def __init__(self, config: dict[str, Any]):
+        """Initialize Anthropic provider with configuration."""
+        super().__init__(config)
+        self.client: anthropic.Anthropic | None = None
+
+    def get_bash_command(self, prompt: str) -> str:
+        """Generate bash command from natural language prompt."""
+        if self.client is None:
+            self.validate_config()
+
+        # After validate_config(), client should be set
+        assert self.client is not None, "Client should be initialized after validation"
+
+        try:
+            response = self.client.messages.create(
+                model=self.config.get("model_name", "claude-3-haiku-20240307"),
+                max_tokens=self.config.get("max_tokens", 150),
+                temperature=self.config.get("temperature", 0.0),
+                system=self.config.get("system_prompt", SYSTEM_PROMPT),
+                messages=[{"role": "user", "content": prompt}],
+            )
+            return response.content[0].text
+        except Exception as e:
+            self._handle_api_error(e)
+
+    def validate_config(self) -> None:
+        """Validate provider configuration and API key."""
+        api_key_env = self.config.get("api_key_env", "ANTHROPIC_API_KEY")
+        api_key = os.environ.get(api_key_env)
+
+        if not api_key:
+            raise AuthenticationError(
+                f"Error: {api_key_env} environment variable is required"
+            )
+
+        self.client = anthropic.Anthropic(api_key=api_key)
+
+    def _handle_api_error(self, error: Exception):
+        """Handle API errors and map them to standard exceptions."""
+        error_str = str(error).lower()
+
+        if "authentication" in error_str or "unauthorized" in error_str:
+            raise AuthenticationError("Error: Invalid API key")
+        elif "rate limit" in error_str:
+            raise RateLimitError("Error: API rate limit exceeded")
+        else:
+            raise APIError(f"Error: API request failed - {error}")
+
+    @classmethod
+    def get_default_config(cls) -> dict[str, Any]:
+        """Return default configuration for Anthropic provider."""
+        return {
+            "model_name": "claude-3-haiku-20240307",
+            "max_tokens": 150,
+            "api_key_env": "ANTHROPIC_API_KEY",
+            "temperature": 0.0,
+            "system_prompt": SYSTEM_PROMPT,
+        }

ask/providers/base.py

@@ -0,0 +1,28 @@
+"""Abstract base class for all providers."""
+
+from abc import ABC, abstractmethod
+from typing import Any
+
+
+class ProviderInterface(ABC):
+    """Abstract base class for all AI providers."""
+
+    def __init__(self, config: dict[str, Any]):
+        """Initialize provider with configuration."""
+        self.config = config
+
+    @abstractmethod
+    def get_bash_command(self, prompt: str) -> str:
+        """Generate bash command from natural language prompt."""
+        pass
+
+    @abstractmethod
+    def validate_config(self) -> None:
+        """Validate provider configuration and API key."""
+        pass
+
+    @classmethod
+    @abstractmethod
+    def get_default_config(cls) -> dict[str, Any]:
+        """Return default configuration for this provider."""
+        pass

ask/providers/openai.py

@@ -0,0 +1,106 @@
+"""OpenAI provider implementation."""
+
+import os
+import re
+from typing import Any, NoReturn
+
+import openai
+
+from ask.config import SYSTEM_PROMPT
+from ask.exceptions import APIError, AuthenticationError, RateLimitError
+from ask.providers.base import ProviderInterface
+
+
+class OpenAIProvider(ProviderInterface):
+    """OpenAI provider implementation."""
+
+    def __init__(self, config: dict[str, Any]):
+        """Initialize OpenAI provider with configuration.
+
+        Args:
+            config: The configuration for the OpenAI provider
+        """
+        super().__init__(config)
+        self.client: openai.OpenAI | None = None
+
+    def get_bash_command(self, prompt: str) -> str:
+        """Generate bash command from natural language prompt.
+
+        Args:
+            prompt: The natural language prompt to generate a bash command for
+
+        Returns:
+            The generated bash command
+        """
+        if self.client is None:
+            self.validate_config()
+
+        # After validate_config(), client should be set
+        assert self.client is not None, "Client should be initialized after validation"
+
+        try:
+            response = self.client.chat.completions.create(
+                model=self.config.get("model_name", "gpt-4o-mini"),
+                max_completion_tokens=self.config.get("max_tokens", 150),
+                temperature=self.config.get("temperature", 0.0),
+                messages=[
+                    {
+                        "role": "system",
+                        "content": self.config.get("system_prompt", SYSTEM_PROMPT),
+                    },
+                    {"role": "user", "content": prompt},
+                ],
+            )
+            content = response.choices[0].message.content
+            if content is None:
+                raise APIError("Error: API returned empty response")
+            # Remove ```bash and ``` from the content
+            re_match = re.search(r"```bash\n(.*)\n```", content)
+            if re_match is None:
+                return content
+            else:
+                return re_match.group(1)
+        except Exception as e:
+            self._handle_api_error(e)
+
+    def validate_config(self) -> None:
+        """Validate provider configuration and API key."""
+        api_key_env = self.config.get("api_key_env", "OPENAI_API_KEY")
+        api_key = os.environ.get(api_key_env)
+
+        if not api_key:
+            raise AuthenticationError(
+                f"Error: {api_key_env} environment variable is required"
+            )
+
+        self.client = openai.OpenAI(api_key=api_key)
+
+    def _handle_api_error(self, error: Exception) -> NoReturn:
+        """Handle API errors and map them to standard exceptions.
+
+        Args:
+            error: The exception to handle
+
+        Raises:
+            AuthenticationError: If the API key is invalid
+            RateLimitError: If the API rate limit is exceeded
+        """
+        error_str = str(error).lower()
+
+        if "authentication" in error_str or "unauthorized" in error_str:
+            raise AuthenticationError("Error: Invalid API key")
+        elif "rate limit" in error_str or "quota" in error_str:
+            raise RateLimitError("Error: API rate limit exceeded")
+        else:
+            raise APIError(f"Error: API request failed - {error}")
+
+    @classmethod
+    def get_default_config(cls) -> dict[str, Any]:
+        """Return default configuration for OpenAI provider."""
+        return {
+            "model_name": "gpt-4o-mini",
+            "max_tokens": 150,
+            "api_key_env": "OPENAI_API_KEY",
+            "temperature": 0.0,
+            "system_prompt": SYSTEM_PROMPT,
+        }