thailint 0.1.5__py3-none-any.whl → 0.2.0__py3-none-any.whl

src/orchestrator/core.py

@@ -89,11 +89,12 @@ class Orchestrator:
     detection to provide comprehensive linting of files and directories.
     """
 
-    def __init__(self, project_root: Path | None = None):
+    def __init__(self, project_root: Path | None = None, config: dict | None = None):
         """Initialize orchestrator.
 
         Args:
             project_root: Root directory of project. Defaults to current directory.
+            config: Optional pre-loaded configuration dict. If provided, skips config file loading.
         """
         self.project_root = project_root or Path.cwd()
         self.registry = RuleRegistry()
@@ -103,12 +104,16 @@ class Orchestrator:
         # Auto-discover and register all linting rules from src.linters
         self.registry.discover_rules("src.linters")
 
-        # Load configuration from project root
-        config_path = self.project_root / ".thailint.yaml"
-        if not config_path.exists():
-            config_path = self.project_root / ".thailint.json"
+        # Use provided config or load from project root
+        if config is not None:
+            self.config = config
+        else:
+            # Load configuration from project root
+            config_path = self.project_root / ".thailint.yaml"
+            if not config_path.exists():
+                config_path = self.project_root / ".thailint.json"
 
-        self.config = self.config_loader.load(config_path)
+            self.config = self.config_loader.load(config_path)
 
     def lint_file(self, file_path: Path) -> list[Violation]:
         """Lint a single file.
@@ -124,10 +129,33 @@ class Orchestrator:
 
         language = detect_language(file_path)
         rules = self._get_rules_for_file(file_path, language)
-        context = FileLintContext(file_path, language, metadata=self.config)
+
+        # Add project_root to metadata for rules that need it (e.g., DRY linter cache)
+        metadata = {**self.config, "_project_root": self.project_root}
+        context = FileLintContext(file_path, language, metadata=metadata)
 
         return self._execute_rules(rules, context)
 
+    def lint_files(self, file_paths: list[Path]) -> list[Violation]:
+        """Lint multiple files.
+
+        Args:
+            file_paths: List of file paths to lint.
+
+        Returns:
+            List of violations found across all files.
+        """
+        violations = []
+
+        for file_path in file_paths:
+            violations.extend(self.lint_file(file_path))
+
+        # Call finalize() on all rules after processing all files
+        for rule in self.registry.list_all():
+            violations.extend(rule.finalize())
+
+        return violations
+
     def _execute_rules(
         self, rules: list[BaseLintRule], context: BaseLintContext
     ) -> list[Violation]:
@@ -150,6 +178,9 @@ class Orchestrator:
         """Safely check a rule, returning empty list on error."""
         try:
             return rule.check(context)
+        except ValueError:
+            # Re-raise configuration validation errors (these are user-facing)
+            raise
         except Exception:  # nosec B112
             # Skip rules that fail (defensive programming)
             return []
@@ -171,6 +202,10 @@ class Orchestrator:
             if file_path.is_file():
                 violations.extend(self.lint_file(file_path))
 
+        # Call finalize() on all rules after processing all files
+        for rule in self.registry.list_all():
+            violations.extend(rule.finalize())
+
         return violations
 
     def _get_rules_for_file(self, file_path: Path, language: str) -> list[BaseLintRule]:

src/utils/__init__.py

@@ -0,0 +1,4 @@
+"""Utils package for shared utilities.
+
+This package provides common utility functions used across the linter framework.
+"""

src/utils/project_root.py

@@ -0,0 +1,84 @@
+"""Project root detection utility.
+
+Purpose: Centralized project root detection for consistent file placement
+Scope: Single source of truth for finding project root directory
+
+Overview: Uses pyprojroot package to provide reliable project root detection across
+    different environments (development, CI/CD, user installations). Delegates all
+    project root detection logic to the industry-standard pyprojroot library which
+    handles various project markers and edge cases that we cannot anticipate.
+
+Dependencies: pyprojroot for robust project root detection
+
+Exports: is_project_root(), get_project_root()
+
+Interfaces: Path-based functions for checking and finding project roots
+
+Implementation: Pure delegation to pyprojroot with fallback to start_path when no root found
+"""
+
+from pathlib import Path
+
+from pyprojroot import find_root
+
+
+def is_project_root(path: Path) -> bool:
+    """Check if a directory is a project root.
+
+    Uses pyprojroot to detect if the given path is a project root by checking
+    if finding the root from this path returns the same path.
+
+    Args:
+        path: Directory path to check
+
+    Returns:
+        True if the directory is a project root, False otherwise
+
+    Examples:
+        >>> is_project_root(Path("/home/user/myproject"))
+        True
+        >>> is_project_root(Path("/home/user/myproject/src"))
+        False
+    """
+    if not path.exists() or not path.is_dir():
+        return False
+
+    try:
+        # Find root from this path - if it equals this path, it's a root
+        found_root = find_root(path)
+        return found_root == path.resolve()
+    except (OSError, RuntimeError):
+        # pyprojroot couldn't find a root
+        return False
+
+
+def get_project_root(start_path: Path | None = None) -> Path:
+    """Find project root by walking up the directory tree.
+
+    This is the single source of truth for project root detection.
+    All code that needs to find the project root should use this function.
+
+    Uses pyprojroot which searches for standard project markers defined by the
+    pyprojroot library (git repos, Python projects, etc).
+
+    Args:
+        start_path: Directory to start searching from. If None, uses current working directory.
+
+    Returns:
+        Path to project root directory. If no root markers found, returns the start_path.
+
+    Examples:
+        >>> root = get_project_root()
+        >>> config_file = root / ".thailint.yaml"
+    """
+    if start_path is None:
+        start_path = Path.cwd()
+
+    current = start_path.resolve()
+
+    try:
+        # Use pyprojroot to find the project root
+        return find_root(current)
+    except (OSError, RuntimeError):
+        # No project markers found, return the start path
+        return current