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

coding_assistant/validation/params.py

@@ -0,0 +1,280 @@
+"""Parameter validation for CLI commands."""
+
+from typing import Optional, List, Any
+
+from coding_assistant.exceptions.validation import (
+    ValidationError,
+    InvalidParameterError
+)
+
+
+class ParameterValidator:
+    """
+    Validates CLI command parameters.
+
+    Ensures parameters are within acceptable ranges and formats.
+    """
+
+    @staticmethod
+    def validate_top_k(value: int) -> int:
+        """
+        Validate top_k parameter for search results.
+
+        Args:
+            value: Number of results to return
+
+        Returns:
+            Validated value
+
+        Raises:
+            InvalidParameterError: If value is invalid
+        """
+        if not isinstance(value, int):
+            raise InvalidParameterError(
+                "top_k",
+                value,
+                "positive integer"
+            )
+
+        if value < 1:
+            raise InvalidParameterError(
+                "top_k",
+                value,
+                "positive integer (>= 1)"
+            )
+
+        if value > 100:
+            raise InvalidParameterError(
+                "top_k",
+                value,
+                "positive integer (<= 100)",
+                suggestion="Use a smaller value (1-100) for better performance"
+            )
+
+        return value
+
+    @staticmethod
+    def validate_max_files(value: int) -> int:
+        """
+        Validate max_files parameter for indexing.
+
+        Args:
+            value: Maximum number of files to index
+
+        Returns:
+            Validated value
+
+        Raises:
+            InvalidParameterError: If value is invalid
+        """
+        if not isinstance(value, int):
+            raise InvalidParameterError(
+                "max_files",
+                value,
+                "positive integer"
+            )
+
+        if value < 1:
+            raise InvalidParameterError(
+                "max_files",
+                value,
+                "positive integer (>= 1)"
+            )
+
+        if value > 10000:
+            raise InvalidParameterError(
+                "max_files",
+                value,
+                "positive integer (<= 10000)",
+                suggestion="Use a smaller value for better performance. 100-1000 is usually sufficient."
+            )
+
+        return value
+
+    @staticmethod
+    def validate_temperature(value: float) -> float:
+        """
+        Validate LLM temperature parameter.
+
+        Args:
+            value: Temperature value
+
+        Returns:
+            Validated value
+
+        Raises:
+            InvalidParameterError: If value is invalid
+        """
+        if not isinstance(value, (int, float)):
+            raise InvalidParameterError(
+                "temperature",
+                value,
+                "number between 0.0 and 2.0"
+            )
+
+        value = float(value)
+
+        if value < 0.0 or value > 2.0:
+            raise InvalidParameterError(
+                "temperature",
+                value,
+                "number between 0.0 and 2.0",
+                suggestion="Use 0.0 for deterministic, 0.7 for balanced, 1.0+ for creative"
+            )
+
+        return value
+
+    @staticmethod
+    def validate_hybrid_alpha(value: float) -> float:
+        """
+        Validate hybrid search alpha parameter.
+
+        Args:
+            value: Alpha value (weight for vector search)
+
+        Returns:
+            Validated value
+
+        Raises:
+            InvalidParameterError: If value is invalid
+        """
+        if not isinstance(value, (int, float)):
+            raise InvalidParameterError(
+                "hybrid_alpha",
+                value,
+                "number between 0.0 and 1.0"
+            )
+
+        value = float(value)
+
+        if value < 0.0 or value > 1.0:
+            raise InvalidParameterError(
+                "hybrid_alpha",
+                value,
+                "number between 0.0 and 1.0",
+                suggestion="Use 0.0 for keyword-only, 0.5 for balanced, 1.0 for vector-only"
+            )
+
+        return value
+
+    @staticmethod
+    def validate_provider(value: str, allowed_providers: Optional[List[str]] = None) -> str:
+        """
+        Validate LLM provider parameter.
+
+        Args:
+            value: Provider name
+            allowed_providers: List of allowed providers
+
+        Returns:
+            Validated provider name
+
+        Raises:
+            InvalidParameterError: If provider is invalid
+        """
+        if allowed_providers is None:
+            allowed_providers = ['ollama', 'openai', 'claude', 'mock']
+
+        value_lower = value.lower()
+
+        if value_lower not in allowed_providers:
+            raise InvalidParameterError(
+                "provider",
+                value,
+                f"one of: {', '.join(allowed_providers)}",
+                suggestion=f"Choose from: {', '.join(allowed_providers)}"
+            )
+
+        return value_lower
+
+    @staticmethod
+    def validate_file_type(value: str) -> str:
+        """
+        Validate file type filter parameter.
+
+        Args:
+            value: File type (extension or language)
+
+        Returns:
+            Validated file type
+
+        Raises:
+            InvalidParameterError: If file type is invalid
+        """
+        common_types = [
+            'python', 'py',
+            'javascript', 'js', 'jsx',
+            'typescript', 'ts', 'tsx',
+            'java',
+            'cpp', 'c', 'h',
+            'csharp', 'cs',
+            'go',
+            'rust', 'rs',
+            'ruby', 'rb',
+            'php',
+            'swift',
+            'kotlin', 'kt'
+        ]
+
+        value_lower = value.lower()
+
+        # Map common names to extensions
+        type_map = {
+            'python': 'py',
+            'javascript': 'js',
+            'typescript': 'ts',
+            'csharp': 'cs',
+            'rust': 'rs',
+            'ruby': 'rb',
+            'kotlin': 'kt'
+        }
+
+        if value_lower in type_map:
+            return type_map[value_lower]
+
+        if value_lower in common_types:
+            return value_lower
+
+        # Allow any extension starting with .
+        if value.startswith('.'):
+            return value[1:]  # Remove dot
+
+        return value_lower
+
+    @staticmethod
+    def validate_context_size(value: int) -> int:
+        """
+        Validate context size parameter.
+
+        Args:
+            value: Number of context chunks
+
+        Returns:
+            Validated value
+
+        Raises:
+            InvalidParameterError: If value is invalid
+        """
+        if not isinstance(value, int):
+            raise InvalidParameterError(
+                "context_size",
+                value,
+                "positive integer"
+            )
+
+        if value < 1:
+            raise InvalidParameterError(
+                "context_size",
+                value,
+                "positive integer (>= 1)"
+            )
+
+        if value > 50:
+            raise InvalidParameterError(
+                "context_size",
+                value,
+                "positive integer (<= 50)",
+                suggestion="Use a smaller value (1-20) for better performance"
+            )
+
+        return value

coding_assistant/validation/sanitizers.py

@@ -0,0 +1,243 @@
+"""Input sanitization utilities."""
+
+import re
+import html
+from typing import Optional
+
+
+class InputSanitizer:
+    """
+    Sanitizes user inputs to prevent injection attacks.
+
+    Provides methods for cleaning and escaping potentially dangerous input.
+    """
+
+    @staticmethod
+    def sanitize_query(query: str, max_length: int = 500) -> str:
+        """
+        Sanitize search query.
+
+        Args:
+            query: User query
+            max_length: Maximum query length
+
+        Returns:
+            Sanitized query
+        """
+        if not query:
+            return ""
+
+        # Strip whitespace
+        query = query.strip()
+
+        # Remove null bytes
+        query = query.replace('\x00', '')
+
+        # Remove control characters except newline and tab
+        query = ''.join(char for char in query if ord(char) >= 32 or char in '\n\t')
+
+        # Normalize whitespace
+        query = re.sub(r'\s+', ' ', query)
+
+        # Truncate if needed
+        if len(query) > max_length:
+            query = query[:max_length]
+
+        return query
+
+    @staticmethod
+    def sanitize_file_path(path: str) -> str:
+        """
+        Sanitize file path.
+
+        Args:
+            path: File path
+
+        Returns:
+            Sanitized path
+        """
+        if not path:
+            return ""
+
+        # Remove null bytes
+        path = path.replace('\x00', '')
+
+        # Remove dangerous characters
+        dangerous_chars = ['<', '>', '|', '&', ';', '`', '$', '(', ')']
+        for char in dangerous_chars:
+            path = path.replace(char, '')
+
+        # Normalize path separators
+        path = path.replace('\\', '/')
+
+        # Remove consecutive slashes
+        path = re.sub(r'/+', '/', path)
+
+        return path.strip()
+
+    @staticmethod
+    def sanitize_command(command: str) -> str:
+        """
+        Sanitize command string.
+
+        Args:
+            command: Command string
+
+        Returns:
+            Sanitized command
+        """
+        if not command:
+            return ""
+
+        # Remove null bytes
+        command = command.replace('\x00', '')
+
+        # Remove dangerous shell characters
+        dangerous_chars = ['|', '&', ';', '`', '$', '(', ')', '<', '>', '\n']
+        for char in dangerous_chars:
+            command = command.replace(char, '')
+
+        return command.strip()
+
+    @staticmethod
+    def escape_html(text: str) -> str:
+        """
+        Escape HTML special characters.
+
+        Args:
+            text: Text to escape
+
+        Returns:
+            HTML-escaped text
+        """
+        if not text:
+            return ""
+
+        return html.escape(text)
+
+    @staticmethod
+    def sanitize_code(code: str, language: Optional[str] = None) -> str:
+        """
+        Sanitize code input.
+
+        Args:
+            code: Code string
+            language: Programming language (optional)
+
+        Returns:
+            Sanitized code
+        """
+        if not code:
+            return ""
+
+        # Remove null bytes
+        code = code.replace('\x00', '')
+
+        # Remove BOM if present
+        if code.startswith('\ufeff'):
+            code = code[1:]
+
+        # Normalize line endings
+        code = code.replace('\r\n', '\n')
+        code = code.replace('\r', '\n')
+
+        return code
+
+    @staticmethod
+    def sanitize_identifier(identifier: str) -> str:
+        """
+        Sanitize variable/function identifier.
+
+        Args:
+            identifier: Identifier name
+
+        Returns:
+            Sanitized identifier (only alphanumeric and underscore)
+        """
+        if not identifier:
+            return ""
+
+        # Keep only alphanumeric and underscore
+        identifier = re.sub(r'[^a-zA-Z0-9_]', '', identifier)
+
+        # Ensure doesn't start with number
+        if identifier and identifier[0].isdigit():
+            identifier = '_' + identifier
+
+        return identifier
+
+    @staticmethod
+    def sanitize_string(
+        value: str,
+        max_length: Optional[int] = None,
+        allowed_chars: Optional[str] = None
+    ) -> str:
+        """
+        General string sanitization.
+
+        Args:
+            value: String to sanitize
+            max_length: Maximum length
+            allowed_chars: Regex pattern of allowed characters
+
+        Returns:
+            Sanitized string
+        """
+        if not value:
+            return ""
+
+        # Remove null bytes
+        value = value.replace('\x00', '')
+
+        # Filter by allowed characters
+        if allowed_chars:
+            value = ''.join(char for char in value if re.match(allowed_chars, char))
+
+        # Strip whitespace
+        value = value.strip()
+
+        # Truncate if needed
+        if max_length and len(value) > max_length:
+            value = value[:max_length]
+
+        return value
+
+    @staticmethod
+    def remove_ansi_codes(text: str) -> str:
+        """
+        Remove ANSI color codes from text.
+
+        Args:
+            text: Text with potential ANSI codes
+
+        Returns:
+            Text without ANSI codes
+        """
+        if not text:
+            return ""
+
+        # Remove ANSI escape sequences
+        ansi_escape = re.compile(r'\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])')
+        return ansi_escape.sub('', text)
+
+    @staticmethod
+    def truncate_string(
+        text: str,
+        max_length: int,
+        suffix: str = "..."
+    ) -> str:
+        """
+        Truncate string to maximum length.
+
+        Args:
+            text: Text to truncate
+            max_length: Maximum length
+            suffix: Suffix to add when truncated
+
+        Returns:
+            Truncated string
+        """
+        if not text or len(text) <= max_length:
+            return text
+
+        return text[:max_length - len(suffix)] + suffix

coding_assistant/vcs/__init__.py

@@ -0,0 +1,5 @@
+"""Version control system integration."""
+
+from coding_assistant.vcs.git import GitIntegration
+
+__all__ = ['GitIntegration']