ai-coding-assistant 0.5.0__py3-none-any.whl

coding_assistant/utils/keystore.py

@@ -0,0 +1,206 @@
+"""Secure API key storage for cloud LLM providers."""
+
+import json
+import os
+from pathlib import Path
+from typing import Optional, List, Dict
+
+
+class KeyStore:
+    """
+    Secure storage for API keys.
+
+    Stores API keys in a JSON file with restricted permissions (600).
+    Keys are stored at: ~/.coding_assistant/api_keys.json
+    """
+
+    # Valid provider names (allowlist for security)
+    VALID_PROVIDERS = ["groq", "together", "gemini", "openai", "claude", "anthropic"]
+
+    def __init__(self, storage_dir: Optional[Path] = None):
+        """
+        Initialize keystore.
+
+        Args:
+            storage_dir: Directory to store keys (default: ~/.coding_assistant)
+        """
+        if storage_dir is None:
+            storage_dir = Path.home() / ".coding_assistant"
+
+        self.storage_dir = Path(storage_dir)
+        self.storage_dir.mkdir(parents=True, exist_ok=True)
+        self.keys_file = self.storage_dir / "api_keys.json"
+
+        # Ensure file has secure permissions if it exists
+        if self.keys_file.exists():
+            self._ensure_secure_permissions()
+
+    def set_key(self, provider: str, api_key: str) -> bool:
+        """
+        Store API key for a provider.
+
+        Args:
+            provider: Provider name (groq, together, openai, claude)
+            api_key: API key to store
+
+        Returns:
+            True if key was stored successfully
+
+        Raises:
+            ValueError: If provider is not in allowlist
+        """
+        # Validate provider
+        if provider.lower() not in self.VALID_PROVIDERS:
+            raise ValueError(
+                f"Invalid provider: {provider}. "
+                f"Must be one of: {', '.join(self.VALID_PROVIDERS)}"
+            )
+
+        # Load existing keys
+        keys = self._load_keys()
+
+        # Update key
+        keys[provider.lower()] = api_key
+
+        # Save with secure permissions
+        self._save_keys(keys)
+
+        return True
+
+    def get_key(self, provider: str) -> Optional[str]:
+        """
+        Get API key for a provider.
+
+        Args:
+            provider: Provider name
+
+        Returns:
+            API key if found, None otherwise
+        """
+        keys = self._load_keys()
+        return keys.get(provider.lower())
+
+    def remove_key(self, provider: str) -> bool:
+        """
+        Remove API key for a provider.
+
+        Args:
+            provider: Provider name
+
+        Returns:
+            True if key was removed, False if key didn't exist
+        """
+        keys = self._load_keys()
+
+        if provider.lower() in keys:
+            del keys[provider.lower()]
+            self._save_keys(keys)
+            return True
+
+        return False
+
+    def list_providers(self) -> List[str]:
+        """
+        List all providers with stored API keys.
+
+        Returns:
+            List of provider names
+        """
+        keys = self._load_keys()
+        return list(keys.keys())
+
+    def get_all_keys(self) -> Dict[str, str]:
+        """
+        Get all stored API keys.
+
+        Returns:
+            Dictionary of provider -> API key
+        """
+        return self._load_keys()
+
+    def clear_all(self) -> bool:
+        """
+        Remove all stored API keys.
+
+        Returns:
+            True if keys were cleared
+        """
+        self._save_keys({})
+        return True
+
+    def _load_keys(self) -> Dict[str, str]:
+        """
+        Load API keys from storage.
+
+        Returns:
+            Dictionary of provider -> API key
+        """
+        if not self.keys_file.exists():
+            return {}
+
+        try:
+            with open(self.keys_file, 'r') as f:
+                keys = json.load(f)
+                # Ensure it's a dict
+                if not isinstance(keys, dict):
+                    return {}
+                return keys
+        except (json.JSONDecodeError, IOError):
+            # If file is corrupted, return empty dict
+            return {}
+
+    def _save_keys(self, keys: Dict[str, str]) -> None:
+        """
+        Save API keys to storage with secure permissions.
+
+        Args:
+            keys: Dictionary of provider -> API key
+        """
+        # Write to file
+        with open(self.keys_file, 'w') as f:
+            json.dump(keys, f, indent=2)
+
+        # Set secure permissions (owner read/write only)
+        self._ensure_secure_permissions()
+
+    def _ensure_secure_permissions(self) -> None:
+        """
+        Ensure keys file has secure permissions (600).
+
+        Only the owner should be able to read/write the file.
+        """
+        try:
+            # chmod 600 (owner read/write only)
+            os.chmod(self.keys_file, 0o600)
+        except Exception:
+            # If chmod fails (e.g., on Windows), continue anyway
+            # Windows doesn't use UNIX permissions
+            pass
+
+    def mask_key(self, api_key: str) -> str:
+        """
+        Mask an API key for display (show only first 8 and last 4 characters).
+
+        Args:
+            api_key: API key to mask
+
+        Returns:
+            Masked API key (e.g., "gsk_1234...xyz9")
+        """
+        if not api_key or len(api_key) < 12:
+            return "***"
+
+        return f"{api_key[:8]}...{api_key[-4:]}"
+
+    def get_masked_keys(self) -> Dict[str, str]:
+        """
+        Get all keys with masking for safe display.
+
+        Returns:
+            Dictionary of provider -> masked API key
+        """
+        keys = self._load_keys()
+        return {
+            provider: self.mask_key(key)
+            for provider, key in keys.items()
+        }

coding_assistant/utils/logger.py

@@ -0,0 +1,32 @@
+"""Simple logging utilities."""
+
+import logging
+from typing import Optional
+
+
+def get_logger(name: str, level: Optional[int] = None) -> logging.Logger:
+    """
+    Get a configured logger instance.
+
+    Args:
+        name: Logger name (usually __name__)
+        level: Optional logging level (defaults to INFO)
+
+    Returns:
+        Configured logger instance
+    """
+    logger = logging.getLogger(name)
+
+    if not logger.handlers:
+        # Configure handler only if not already configured
+        handler = logging.StreamHandler()
+        formatter = logging.Formatter(
+            '%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+            datefmt='%Y-%m-%d %H:%M:%S'
+        )
+        handler.setFormatter(formatter)
+        logger.addHandler(handler)
+
+    logger.setLevel(level or logging.INFO)
+
+    return logger

coding_assistant/utils/progress.py

@@ -0,0 +1,311 @@
+"""Progress indicators and status utilities for consistent UX."""
+
+from typing import Optional, Callable, Any
+from contextlib import contextmanager
+from rich.console import Console
+from rich.progress import (
+    Progress,
+    SpinnerColumn,
+    TextColumn,
+    BarColumn,
+    TaskProgressColumn,
+    TimeRemainingColumn
+)
+
+
+class ProgressManager:
+    """
+    Centralized progress management for consistent UX.
+
+    Provides:
+    - Simple status spinners
+    - Detailed progress bars
+    - Consistent styling
+    """
+
+    def __init__(self, console: Optional[Console] = None):
+        """
+        Initialize progress manager.
+
+        Args:
+            console: Rich console (creates new one if not provided)
+        """
+        self.console = console or Console()
+
+    @contextmanager
+    def status(self, message: str, spinner: str = "dots"):
+        """
+        Show a simple status spinner.
+
+        Args:
+            message: Status message to display
+            spinner: Spinner style (dots, line, arc, etc.)
+
+        Usage:
+            with progress_manager.status("Processing..."):
+                # Long operation
+                pass
+        """
+        with self.console.status(f"[bold green]{message}[/bold green]", spinner=spinner):
+            yield
+
+    @contextmanager
+    def progress_bar(
+        self,
+        description: str,
+        total: Optional[int] = None,
+        show_time: bool = False
+    ):
+        """
+        Show a detailed progress bar.
+
+        Args:
+            description: Task description
+            total: Total steps (None for indeterminate)
+            show_time: Show time remaining
+
+        Usage:
+            with progress_manager.progress_bar("Indexing", total=100) as progress:
+                for i in range(100):
+                    progress.update(i + 1)
+
+        Yields:
+            Progress updater function
+        """
+        columns = [
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+        ]
+
+        if total is not None:
+            columns.append(BarColumn())
+            columns.append(TaskProgressColumn())
+
+            if show_time:
+                columns.append(TimeRemainingColumn())
+
+        with Progress(*columns, console=self.console, transient=False) as progress:
+            task = progress.add_task(f"[cyan]{description}", total=total)
+
+            class Updater:
+                """Simple updater interface."""
+
+                def update(self, completed: Optional[int] = None, advance: Optional[int] = None):
+                    """Update progress."""
+                    if completed is not None:
+                        progress.update(task, completed=completed)
+                    elif advance is not None:
+                        progress.advance(task, advance)
+
+                def set_description(self, description: str):
+                    """Update description."""
+                    progress.update(task, description=f"[cyan]{description}")
+
+            yield Updater()
+
+    def show_operation(
+        self,
+        operation_name: str,
+        operation_fn: Callable,
+        *args,
+        **kwargs
+    ) -> Any:
+        """
+        Execute an operation with automatic progress indication.
+
+        Args:
+            operation_name: Name of the operation
+            operation_fn: Function to execute
+            *args, **kwargs: Arguments for operation_fn
+
+        Returns:
+            Result of operation_fn
+
+        Usage:
+            result = progress_manager.show_operation(
+                "Indexing codebase",
+                retriever.index_codebase,
+                max_files=100
+            )
+        """
+        with self.status(operation_name):
+            return operation_fn(*args, **kwargs)
+
+    def show_steps(self, steps: list[tuple[str, Callable]]) -> list[Any]:
+        """
+        Execute multiple steps with progress tracking.
+
+        Args:
+            steps: List of (step_name, step_function) tuples
+
+        Returns:
+            List of results from each step
+
+        Usage:
+            results = progress_manager.show_steps([
+                ("Parsing code", parser.parse),
+                ("Generating embeddings", embedder.embed),
+                ("Storing results", storage.save)
+            ])
+        """
+        results = []
+
+        with self.progress_bar("Executing steps", total=len(steps)) as progress:
+            for i, (step_name, step_fn) in enumerate(steps, 1):
+                progress.set_description(f"{step_name}...")
+
+                try:
+                    result = step_fn()
+                    results.append(result)
+                except Exception as e:
+                    self.console.print(f"[red]✗ {step_name} failed: {e}[/red]")
+                    raise
+
+                progress.update(i)
+
+        return results
+
+
+# Global instance for convenience
+_default_progress_manager: Optional[ProgressManager] = None
+
+
+def get_progress_manager(console: Optional[Console] = None) -> ProgressManager:
+    """
+    Get global progress manager instance.
+
+    Args:
+        console: Optional console to use
+
+    Returns:
+        ProgressManager instance
+    """
+    global _default_progress_manager
+
+    if _default_progress_manager is None or console is not None:
+        _default_progress_manager = ProgressManager(console)
+
+    return _default_progress_manager
+
+
+# Convenience functions
+def status(message: str, console: Optional[Console] = None):
+    """Context manager for simple status spinner."""
+    return get_progress_manager(console).status(message)
+
+
+def progress_bar(
+    description: str,
+    total: Optional[int] = None,
+    show_time: bool = False,
+    console: Optional[Console] = None
+):
+    """Context manager for progress bar."""
+    return get_progress_manager(console).progress_bar(description, total, show_time)
+
+
+def show_operation(
+    operation_name: str,
+    operation_fn: Callable,
+    *args,
+    console: Optional[Console] = None,
+    **kwargs
+) -> Any:
+    """Execute operation with progress."""
+    return get_progress_manager(console).show_operation(
+        operation_name, operation_fn, *args, **kwargs
+    )
+
+
+# Progress callback helpers
+class ProgressCallback:
+    """
+    Progress callback for long-running operations.
+
+    Usage:
+        callback = ProgressCallback(total=100)
+        for i in range(100):
+            # ... work ...
+            callback.update(i + 1)
+    """
+
+    def __init__(
+        self,
+        total: int,
+        description: str = "Processing",
+        console: Optional[Console] = None
+    ):
+        """
+        Initialize progress callback.
+
+        Args:
+            total: Total number of items
+            description: Progress description
+            console: Rich console
+        """
+        self.total = total
+        self.description = description
+        self.console = console or Console()
+        self.current = 0
+
+        self.progress = Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            BarColumn(),
+            TaskProgressColumn(),
+            console=self.console
+        )
+
+        self.task = None
+        self._started = False
+
+    def __enter__(self):
+        """Start progress display."""
+        self.progress.__enter__()
+        self.task = self.progress.add_task(
+            f"[cyan]{self.description}",
+            total=self.total
+        )
+        self._started = True
+        return self
+
+    def __exit__(self, *args):
+        """Stop progress display."""
+        self.progress.__exit__(*args)
+        self._started = False
+
+    def update(self, current: int, description: Optional[str] = None):
+        """
+        Update progress.
+
+        Args:
+            current: Current progress value
+            description: Optional new description
+        """
+        if not self._started:
+            return
+
+        self.current = current
+
+        if description:
+            self.progress.update(
+                self.task,
+                completed=current,
+                description=f"[cyan]{description}"
+            )
+        else:
+            self.progress.update(self.task, completed=current)
+
+    def advance(self, amount: int = 1):
+        """Advance progress by amount."""
+        if self._started:
+            self.current += amount
+            self.progress.advance(self.task, amount)
+
+    def set_description(self, description: str):
+        """Update description."""
+        if self._started:
+            self.progress.update(
+                self.task,
+                description=f"[cyan]{description}"
+            )

coding_assistant/validation/__init__.py

@@ -0,0 +1,13 @@
+"""Input validation utilities."""
+
+from coding_assistant.validation.inputs import InputValidator
+from coding_assistant.validation.files import FileValidator
+from coding_assistant.validation.params import ParameterValidator
+from coding_assistant.validation.sanitizers import InputSanitizer
+
+__all__ = [
+    'InputValidator',
+    'FileValidator',
+    'ParameterValidator',
+    'InputSanitizer',
+]