auto-coder 1.0.0__py3-none-any.whl → 2.0.1__py3-none-any.whl

autocoder/common/linter_core/base_linter.py

@@ -0,0 +1,61 @@
+"""
+Simple base class for language-specific linters.
+"""
+
+from abc import ABC, abstractmethod
+from typing import List, Optional, Dict, Any, Union
+from pathlib import Path
+
+from .models.lint_result import LintResult
+
+
+class BaseLinter(ABC):
+    """Base class for all language linters."""
+    
+    def __init__(self, config: Optional[Dict[str, Any]] = None):
+        """Initialize with optional configuration."""
+        self.config = config or {}
+    
+    @property
+    def name(self) -> str:
+        """Name of the linter."""
+        return self.__class__.__name__
+    
+    @property
+    @abstractmethod
+    def supported_extensions(self) -> List[str]:
+        """Supported file extensions (e.g., ['.py', '.pyi'])."""
+        pass
+    
+    @property
+    @abstractmethod
+    def language_name(self) -> str:
+        """Human-readable language name."""
+        pass
+    
+    @abstractmethod
+    def is_available(self) -> bool:
+        """Check if the linter tools are available."""
+        pass
+    
+    @abstractmethod
+    def lint_file(self, file_path: Union[str, Path]) -> LintResult:
+        """
+        Lint a single file and return the result.
+        
+        Args:
+            file_path: Path to the file to lint
+            
+        Returns:
+            LintResult with the linting output
+        """
+        pass
+    
+    def can_lint_file(self, file_path: Union[str, Path]) -> bool:
+        """Check if this linter can handle the given file."""
+        path = Path(file_path)
+        return path.suffix.lower() in self.supported_extensions
+    
+    def get_config_value(self, key: str, default: Any = None) -> Any:
+        """Get a configuration value."""
+        return self.config.get(key, default) 

autocoder/common/linter_core/config_loader.py

@@ -0,0 +1,271 @@
+"""
+Centralized configuration loader for the linter core module.
+
+This module provides comprehensive configuration loading from multiple sources
+with proper priority handling and format support.
+"""
+
+import os
+import json
+from typing import Dict, Any, Optional, List
+from pathlib import Path
+from loguru import logger
+
+
+class LinterConfigLoader:
+    """
+    Centralized configuration loader for linter configurations.
+    
+    Loads configuration from multiple sources in priority order:
+    1. Explicit config path (if provided)
+    2. Environment variable AUTOCODER_LINTER_CONFIG
+    3. Project config file (.autocoderlinters/)
+    4. Global user config file (~/.auto-coder/.autocoderlinters/)
+    5. Default configuration
+    """
+    
+    DEFAULT_CONFIG = {
+        'enabled': False,  # Disabled by default for safety
+        'mode': 'warning',
+        'check_after_modification': True,
+        'report': {
+            'format': 'simple',
+            'include_in_result': True
+        }
+    }
+    
+    def __init__(self, source_dir: Optional[str] = None):
+        """
+        Initialize the config loader.
+        
+        Args:
+            source_dir: Base directory for relative path resolution
+        """
+        self.source_dir = source_dir or "."
+    
+    def load_config(self, 
+                   config_path: Optional[str] = None,
+                   config_key: str = 'linter') -> Dict[str, Any]:
+        """
+        Load configuration from multiple sources in priority order.
+        
+        Args:
+            config_path: Explicit path to configuration file
+            config_key: Key to extract from configuration files (for nested configs)
+            
+        Returns:
+            Dictionary containing the loaded configuration
+        """
+        # 1. Check explicit config path
+        if config_path:
+            config = self._load_from_file(config_path, config_key)
+            if config is not None:
+                logger.info(f"Loaded linter config from explicit path: {config_path}")
+                return config
+        
+        # 2. Check environment variable
+        config = self._load_from_environment()
+        if config is not None:
+            return config
+        
+        # 3. Check project config file
+        config = self._load_from_project_config(config_key)
+        if config is not None:
+            return config
+        
+        # 4. Check global user config file
+        config = self._load_from_global_config(config_key)
+        if config is not None:
+            return config
+        
+        # 5. Return default configuration
+        logger.debug("Using default linter configuration")
+        return self.DEFAULT_CONFIG.copy()
+    
+    def _load_from_file(self, file_path: str, config_key: str = 'linter') -> Optional[Dict[str, Any]]:
+        """Load configuration from a specific file."""
+        try:
+            path = Path(file_path)
+            if not path.exists():
+                logger.debug(f"Config file not found: {file_path}")
+                return None
+            
+            with open(path, 'r', encoding='utf-8') as f:
+                if path.suffix.lower() == '.json':
+                    data = json.load(f)
+                else:
+                    # Try YAML if available
+                    try:
+                        import yaml
+                        data = yaml.safe_load(f)
+                    except ImportError:
+                        logger.warning(f"YAML support not available, treating {file_path} as JSON")
+                        f.seek(0)  # Reset file pointer
+                        data = json.load(f)
+            
+            # Extract the specified section if present, otherwise use the whole config
+            config = data.get(config_key, data) if isinstance(data, dict) else data
+            
+            logger.info(f"Successfully loaded config from: {file_path}")
+            return config
+            
+        except Exception as e:
+            logger.error(f"Failed to load config from {file_path}: {e}")
+            return None
+    
+    def _load_from_environment(self) -> Optional[Dict[str, Any]]:
+        """Load configuration from environment variable."""
+        env_config = os.environ.get('AUTOCODER_LINTER_CONFIG')
+        if not env_config:
+            return None
+        
+        try:
+            config = json.loads(env_config)
+            logger.info("Loaded linter config from environment variable")
+            return config
+        except json.JSONDecodeError as e:
+            logger.error(f"Failed to parse AUTOCODER_LINTER_CONFIG: {e}")
+            return None
+    
+    def _load_from_project_config(self, config_key: str = 'linter') -> Optional[Dict[str, Any]]:
+        """Load configuration from project config directory."""
+        project_config_dir = Path(self.source_dir) / '.autocoderlinters'
+        
+        # Try different config file formats in order of preference
+        config_files = [
+            project_config_dir / 'config.json',
+            project_config_dir / 'config.yaml',
+            project_config_dir / 'config.yml',
+            project_config_dir / 'linter.json',
+            project_config_dir / 'linter.yaml',
+            project_config_dir / 'linter.yml',
+        ]
+        
+        for config_file in config_files:
+            if config_file.exists():
+                config = self._load_from_file(str(config_file), config_key)
+                if config is not None:
+                    logger.info(f"Loaded linter config from project: {config_file}")
+                    return config
+        
+        logger.debug(f"No project config found in: {project_config_dir}")
+        return None
+    
+    def _load_from_global_config(self, config_key: str = 'linter') -> Optional[Dict[str, Any]]:
+        """Load configuration from global user config directory."""
+        try:
+            # Use os.path.expanduser to handle ~ on all platforms
+            global_config_dir = Path(os.path.expanduser('~')) / '.auto-coder' / '.autocoderlinters'
+            
+            # Try different config file formats in order of preference
+            config_files = [
+                global_config_dir / 'config.json',
+                global_config_dir / 'config.yaml',
+                global_config_dir / 'config.yml',
+                global_config_dir / 'linter.json',
+                global_config_dir / 'linter.yaml',
+                global_config_dir / 'linter.yml',
+            ]
+            
+            for config_file in config_files:
+                if config_file.exists():
+                    config = self._load_from_file(str(config_file), config_key)
+                    if config is not None:
+                        logger.info(f"Loaded linter config from global user config: {config_file}")
+                        return config
+        
+        except Exception as e:
+            logger.debug(f"Error checking global user config: {e}")
+        
+        logger.debug("No global user config found")
+        return None
+    
+    def validate_config(self, config: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Validate and normalize configuration.
+        
+        Args:
+            config: Raw configuration dictionary
+            
+        Returns:
+            Validated and normalized configuration
+        """
+        # Ensure all required keys exist with defaults
+        validated = self.DEFAULT_CONFIG.copy()
+        
+        if isinstance(config, dict):
+            # Update with provided config
+            validated.update(config)
+            
+            # Validate specific fields
+            if 'mode' in config and config['mode'] not in ['blocking', 'warning', 'silent']:
+                logger.warning(f"Invalid linter mode '{config['mode']}', using 'warning'")
+                validated['mode'] = 'warning'
+            
+            if 'report' in config and isinstance(config['report'], dict):
+                report_config = validated['report']
+                report_config.update(config['report'])
+                
+                if 'format' in config['report'] and config['report']['format'] not in ['simple', 'detailed', 'json']:
+                    logger.warning(f"Invalid report format '{config['report']['format']}', using 'simple'")
+                    report_config['format'] = 'simple'
+        
+        return validated
+    
+    @classmethod
+    def load_manager_config(cls, config_path: Optional[str] = None, 
+                           source_dir: Optional[str] = None) -> Dict[str, Any]:
+        """
+        Load configuration specifically for LinterManager.
+        
+        This is a convenience method that loads the full configuration
+        (not just the linter section) for use by LinterManager.
+        
+        Args:
+            config_path: Explicit path to configuration file
+            source_dir: Base directory for relative path resolution
+            
+        Returns:
+            Full configuration dictionary for LinterManager
+        """
+        loader = cls(source_dir)
+        
+        # Try to load full config (without extracting just 'linter' section)
+        if config_path:
+            config = loader._load_from_file(config_path, config_key=None)
+            if config is not None:
+                return config
+        
+        # Check environment variable for full config
+        env_config = os.environ.get('AUTOCODER_LINTER_CONFIG')
+        if env_config:
+            try:
+                return json.loads(env_config)
+            except json.JSONDecodeError:
+                pass
+        
+        # Check project and global config files
+        for config_source in [loader._load_from_project_config, loader._load_from_global_config]:
+            config = config_source(config_key=None)  # Load full config
+            if config is not None:
+                return config
+        
+        # Return empty config if nothing found
+        return {}
+
+
+def load_linter_config(config_path: Optional[str] = None,
+                      source_dir: Optional[str] = None) -> Dict[str, Any]:
+    """
+    Convenience function to load and validate linter configuration.
+    
+    Args:
+        config_path: Explicit path to configuration file
+        source_dir: Base directory for relative path resolution
+        
+    Returns:
+        Validated linter configuration dictionary
+    """
+    loader = LinterConfigLoader(source_dir)
+    raw_config = loader.load_config(config_path)
+    return loader.validate_config(raw_config)

autocoder/common/linter_core/formatters/base_formatter.py

@@ -0,0 +1,38 @@
+"""
+Base classes for formatting linter results.
+
+This layer allows each linter to define how its results are presented
+without changing the linting logic. By default, a raw formatter returns
+results unchanged (as dictionaries), and consumers may subclass to
+produce pretty text, tables, or other formats.
+"""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import Any, Dict
+
+from ..models.lint_result import LintResult
+
+
+class BaseLintOutputFormatter(ABC):
+    """Abstract formatter for lint results.
+
+    Subclasses implement presentation logic for a single result and a
+    collection of results. The return type is intentionally flexible to
+    support dicts, strings, or other serializable structures.
+    """
+
+    @abstractmethod
+    def format_result(self, result: LintResult) -> Any:
+        """Format a single `LintResult` for presentation."""
+        raise NotImplementedError
+
+    def format_results(self, results: Dict[str, LintResult]) -> Dict[str, Any]:
+        """Format multiple results.
+
+        Default implementation maps input keys to formatted entries using
+        `format_result`. Subclasses may override when a different aggregated
+        structure is desired (e.g., a single text blob, table, or summary).
+        """
+        return {path: self.format_result(result) for path, result in results.items()}

autocoder/common/linter_core/formatters/raw_formatter.py

@@ -0,0 +1,17 @@
+"""
+Default raw formatter that returns lint results as dictionaries, unchanged.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from ..models.lint_result import LintResult
+from .base_formatter import BaseLintOutputFormatter
+
+
+class RawLintOutputFormatter(BaseLintOutputFormatter):
+    """Return lint results as plain dictionaries with embedded summary."""
+
+    def format_result(self, result: LintResult) -> Any:
+        return result.to_dict()

autocoder/common/linter_core/linter.py

@@ -0,0 +1,166 @@
+"""
+Main Linter class that provides a simple interface for code checking.
+"""
+
+import concurrent.futures
+from typing import Dict, List, Optional, Union, Any
+from pathlib import Path
+
+from .base_linter import BaseLinter
+from .models.lint_result import LintResult
+from .linters import PythonLinter, TypeScriptLinter
+
+
+class Linter:
+    """Simple interface for linting files across multiple languages."""
+    
+    def __init__(self, config: Optional[Dict[str, Any]] = None):
+        """
+        Initialize the linter.
+        
+        Args:
+            config: Optional configuration with keys:
+                - max_workers: Maximum parallel workers (default: 4)
+                - python: Python linter config
+                - typescript: TypeScript linter config
+        """
+        self.config = config or {}
+        self.max_workers = self.config.get('max_workers', 4)
+        
+        # Initialize available linters
+        self._linters: Dict[str, BaseLinter] = {}
+        self._init_linters()
+    
+    def _init_linters(self) -> None:
+        """Initialize all available linters."""
+        # Python linter
+        python_config = self.config.get('python', {})
+        python_linter = PythonLinter(python_config)
+        if python_linter.is_available():
+            self._linters['python'] = python_linter
+        
+        # TypeScript linter
+        ts_config = self.config.get('typescript', {})
+        ts_linter = TypeScriptLinter(ts_config)
+        if ts_linter.is_available():
+            self._linters['typescript'] = ts_linter
+    
+    def check_file(self, file_path: Union[str, Path]) -> Optional[LintResult]:
+        """
+        Check a single file.
+        
+        Args:
+            file_path: Path to the file to check
+            
+        Returns:
+            LintResult if the file can be checked, None otherwise
+        """
+        path = Path(file_path)
+        
+        if not path.exists():
+            return LintResult(
+                file_path=str(path),
+                success=False,
+                error=f"File not found: {path}"
+            )
+        
+        # Find appropriate linter
+        for linter in self._linters.values():
+            if linter.can_check(path):
+                return linter.check_file(path)
+        
+        return None  # No linter available for this file type
+    
+    def check_files(self, file_paths: List[Union[str, Path]], 
+                   parallel: bool = True) -> Dict[str, LintResult]:
+        """
+        Check multiple files.
+        
+        Args:
+            file_paths: List of file paths to check
+            parallel: Whether to use parallel processing
+            
+        Returns:
+            Dictionary mapping file paths to their results
+        """
+        results = {}
+        
+        if parallel and len(file_paths) > 1:
+            with concurrent.futures.ThreadPoolExecutor(max_workers=self.max_workers) as executor:
+                future_to_file = {
+                    executor.submit(self.check_file, fp): str(fp) 
+                    for fp in file_paths
+                }
+                
+                for future in concurrent.futures.as_completed(future_to_file):
+                    file_path = future_to_file[future]
+                    try:
+                        result = future.result()
+                        if result:
+                            results[file_path] = result
+                    except Exception as e:
+                        results[file_path] = LintResult(
+                            file_path=file_path,
+                            success=False,
+                            error=str(e)
+                        )
+        else:
+            for file_path in file_paths:
+                result = self.check_file(file_path)
+                if result:
+                    results[str(file_path)] = result
+        
+        return results
+    
+    def check_directory(self, directory: Union[str, Path], 
+                       recursive: bool = True,
+                       extensions: Optional[List[str]] = None) -> Dict[str, LintResult]:
+        """
+        Check all supported files in a directory.
+        
+        Args:
+            directory: Directory to check
+            recursive: Whether to check subdirectories
+            extensions: Specific extensions to check (None = all supported)
+            
+        Returns:
+            Dictionary mapping file paths to their results
+        """
+        path = Path(directory)
+        if not path.exists():
+            return {
+                str(path): LintResult(
+                    file_path=str(path),
+                    success=False,
+                    error=f"Directory not found: {path}"
+                )
+            }
+        
+        # Get all supported extensions if not specified
+        if extensions is None:
+            extensions = []
+            for linter in self._linters.values():
+                extensions.extend(linter.extensions)
+        
+        # Find files
+        files = []
+        pattern = "**/*" if recursive else "*"
+        for ext in set(extensions):
+            files.extend(path.glob(f"{pattern}{ext}"))
+        
+        return self.check_files(files)
+    
+    def get_supported_languages(self) -> List[str]:
+        """Get list of supported languages."""
+        return list(self._linters.keys())
+    
+    def get_supported_extensions(self) -> List[str]:
+        """Get list of all supported file extensions."""
+        extensions = []
+        for linter in self._linters.values():
+            extensions.extend(linter.extensions)
+        return list(set(extensions))
+    
+    def is_available(self, language: str) -> bool:
+        """Check if a specific language linter is available."""
+        return language in self._linters