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

coding_assistant/exceptions/storage.py

@@ -0,0 +1,213 @@
+"""Storage and index-related exceptions."""
+
+from typing import Optional
+from pathlib import Path
+from coding_assistant.exceptions.base import AssistantError
+
+
+class StorageError(AssistantError):
+    """Base exception for storage-related errors."""
+
+    def __init__(
+        self,
+        message: str,
+        recoverable: bool = True,
+        suggestion: Optional[str] = None,
+        **kwargs
+    ):
+        super().__init__(
+            message=message,
+            recoverable=recoverable,
+            suggestion=suggestion,
+            error_code="STORAGE_ERROR",
+            **kwargs
+        )
+
+
+class IndexError(StorageError):
+    """Base exception for index-related errors."""
+    pass
+
+
+class IndexNotFoundError(IndexError):
+    """
+    Codebase index not found.
+
+    Raised when trying to query/search before indexing.
+    """
+
+    def __init__(self, project_path: Optional[Path] = None):
+        """
+        Initialize index not found error.
+
+        Args:
+            project_path: Path to project
+        """
+        message = "Codebase has not been indexed yet"
+        if project_path:
+            message += f" for project: {project_path}"
+
+        super().__init__(
+            message=message,
+            recoverable=True,
+            suggestion=(
+                "Index your codebase first:\n"
+                "  assistant index\n"
+                "\n"
+                "Or specify max files:\n"
+                "  assistant index --max-files 200"
+            ),
+            details={'project_path': str(project_path) if project_path else None}
+        )
+
+
+class IndexCorruptedError(IndexError):
+    """
+    Index is corrupted or unreadable.
+
+    Raised when index exists but cannot be loaded.
+    """
+
+    def __init__(self, reason: Optional[str] = None):
+        """
+        Initialize index corrupted error.
+
+        Args:
+            reason: Reason for corruption
+        """
+        message = "Index is corrupted and cannot be loaded"
+        if reason:
+            message += f": {reason}"
+
+        super().__init__(
+            message=message,
+            recoverable=True,
+            suggestion=(
+                "Rebuild the index:\n"
+                "  assistant index --force\n"
+                "\n"
+                "This will recreate the index from scratch."
+            ),
+            details={'reason': reason}
+        )
+
+
+class IndexingError(IndexError):
+    """
+    Error occurred during indexing.
+
+    Raised when indexing process fails.
+    """
+
+    def __init__(self, file_path: Optional[str] = None, reason: Optional[str] = None):
+        """
+        Initialize indexing error.
+
+        Args:
+            file_path: File being indexed when error occurred
+            reason: Reason for failure
+        """
+        message = "Indexing failed"
+        if file_path:
+            message += f" while processing {file_path}"
+        if reason:
+            message += f": {reason}"
+
+        super().__init__(
+            message=message,
+            recoverable=True,
+            suggestion="Try indexing again or exclude problematic files",
+            details={
+                'file_path': file_path,
+                'reason': reason
+            }
+        )
+
+
+class SessionError(StorageError):
+    """Base exception for session-related errors."""
+    pass
+
+
+class SessionNotFoundError(SessionError):
+    """
+    Session not found.
+
+    Raised when trying to access non-existent session.
+    """
+
+    def __init__(self, session_id: int):
+        """
+        Initialize session not found error.
+
+        Args:
+            session_id: Session ID
+        """
+        super().__init__(
+            message=f"Session {session_id} not found",
+            recoverable=True,
+            suggestion="Check session ID or start a new session with 'assistant chat'",
+            details={'session_id': session_id}
+        )
+
+
+class DatabaseError(StorageError):
+    """
+    Database operation failed.
+
+    Raised when SQLite operations fail.
+    """
+
+    def __init__(self, operation: str, reason: Optional[str] = None):
+        """
+        Initialize database error.
+
+        Args:
+            operation: Database operation being performed
+            reason: Reason for failure
+        """
+        message = f"Database operation '{operation}' failed"
+        if reason:
+            message += f": {reason}"
+
+        super().__init__(
+            message=message,
+            recoverable=True,
+            suggestion="Check database permissions and disk space",
+            details={
+                'operation': operation,
+                'reason': reason
+            }
+        )
+
+
+class CacheError(StorageError):
+    """
+    Cache operation failed.
+
+    Raised when cache read/write fails.
+    """
+
+    def __init__(self, operation: str, cache_type: str, reason: Optional[str] = None):
+        """
+        Initialize cache error.
+
+        Args:
+            operation: Cache operation (get, set, delete)
+            cache_type: Type of cache (embedding, response)
+            reason: Reason for failure
+        """
+        message = f"Cache {operation} failed for {cache_type} cache"
+        if reason:
+            message += f": {reason}"
+
+        super().__init__(
+            message=message,
+            recoverable=True,  # Cache failures should not break functionality
+            suggestion="Cache will be bypassed. Clear cache if issues persist:\n  rm -rf .assistant/cache",
+            details={
+                'operation': operation,
+                'cache_type': cache_type,
+                'reason': reason
+            }
+        )

coding_assistant/exceptions/validation.py

@@ -0,0 +1,230 @@
+"""Input validation exceptions."""
+
+from typing import Optional
+from pathlib import Path
+from coding_assistant.exceptions.base import AssistantError
+
+
+class ValidationError(AssistantError):
+    """
+    Base exception for validation errors.
+
+    Raised when user input is invalid.
+    """
+
+    def __init__(
+        self,
+        field: str,
+        reason: str,
+        value: Optional[str] = None,
+        suggestion: Optional[str] = None
+    ):
+        """
+        Initialize validation error.
+
+        Args:
+            field: Field name that failed validation
+            reason: Reason for validation failure
+            value: Invalid value (optional)
+            suggestion: Suggestion for fixing
+        """
+        message = f"Invalid {field}: {reason}"
+
+        if not suggestion:
+            suggestion = f"Please provide a valid {field}"
+
+        super().__init__(
+            message=message,
+            recoverable=True,
+            suggestion=suggestion,
+            error_code="VALIDATION_ERROR",
+            details={
+                'field': field,
+                'reason': reason,
+                'value': value
+            }
+        )
+
+
+class FileNotFoundError(ValidationError):
+    """
+    File not found.
+
+    Raised when specified file does not exist.
+    """
+
+    def __init__(self, file_path: Path):
+        """
+        Initialize file not found error.
+
+        Args:
+            file_path: Path to missing file
+        """
+        super().__init__(
+            field="file path",
+            reason=f"File not found: {file_path}",
+            value=str(file_path),
+            suggestion=f"Check that the file exists:\n  ls {file_path}"
+        )
+
+
+class InvalidQueryError(ValidationError):
+    """
+    Invalid search query.
+
+    Raised when search query is malformed or too short/long.
+    """
+
+    def __init__(self, query: str, reason: str):
+        """
+        Initialize invalid query error.
+
+        Args:
+            query: Invalid query
+            reason: Reason for invalidity
+        """
+        super().__init__(
+            field="query",
+            reason=reason,
+            value=query[:50] + "..." if len(query) > 50 else query,
+            suggestion="Provide a clear, specific query (3-500 characters)"
+        )
+
+
+class InvalidParameterError(ValidationError):
+    """
+    Invalid parameter value.
+
+    Raised when command parameter is invalid.
+    """
+
+    def __init__(
+        self,
+        parameter: str,
+        value: any,
+        expected: str,
+        suggestion: Optional[str] = None
+    ):
+        """
+        Initialize invalid parameter error.
+
+        Args:
+            parameter: Parameter name
+            value: Invalid value
+            expected: Expected value description
+            suggestion: Optional suggestion
+        """
+        super().__init__(
+            field=parameter,
+            reason=f"Expected {expected}, got {type(value).__name__}: {value}",
+            value=str(value),
+            suggestion=suggestion or f"Provide a valid {parameter} ({expected})"
+        )
+
+
+class EmptyInputError(ValidationError):
+    """
+    Empty input provided.
+
+    Raised when required input is empty.
+    """
+
+    def __init__(self, field: str):
+        """
+        Initialize empty input error.
+
+        Args:
+            field: Field name
+        """
+        super().__init__(
+            field=field,
+            reason="Input cannot be empty",
+            value="",
+            suggestion=f"Provide a non-empty {field}"
+        )
+
+
+class PathSecurityError(ValidationError):
+    """
+    Potentially dangerous file path.
+
+    Raised when path contains suspicious patterns.
+    """
+
+    def __init__(self, file_path: Path, reason: str):
+        """
+        Initialize path security error.
+
+        Args:
+            file_path: Suspicious path
+            reason: Security concern
+        """
+        super().__init__(
+            field="file path",
+            reason=f"Security concern: {reason}",
+            value=str(file_path),
+            suggestion="Use a safe, absolute path within your project"
+        )
+
+
+class CodeSyntaxError(ValidationError):
+    """
+    Code has syntax errors.
+
+    Raised when generated/modified code is invalid.
+    """
+
+    def __init__(
+        self,
+        file_path: Optional[str] = None,
+        line: Optional[int] = None,
+        message: Optional[str] = None
+    ):
+        """
+        Initialize code syntax error.
+
+        Args:
+            file_path: File with syntax error
+            line: Line number
+            message: Error message from parser
+        """
+        reason = "Code has syntax errors"
+        if file_path:
+            reason += f" in {file_path}"
+        if line:
+            reason += f" at line {line}"
+        if message:
+            reason += f": {message}"
+
+        super().__init__(
+            field="code",
+            reason=reason,
+            value=None,
+            suggestion="Fix syntax errors before applying changes"
+        )
+
+
+class ConfigurationError(ValidationError):
+    """
+    Configuration is invalid.
+
+    Raised when config file has errors.
+    """
+
+    def __init__(self, config_file: Path, reason: str):
+        """
+        Initialize configuration error.
+
+        Args:
+            config_file: Configuration file path
+            reason: What's wrong with the config
+        """
+        super().__init__(
+            field="configuration",
+            reason=reason,
+            value=str(config_file),
+            suggestion=(
+                "Fix configuration errors or regenerate default config:\n"
+                "  assistant config --generate"
+            )
+        )

coding_assistant/llm/__init__.py

@@ -0,0 +1 @@
+"""LLM integration module."""