thailint 0.1.0__py3-none-any.whl

src/orchestrator/core.py

@@ -0,0 +1,188 @@
+"""
+Purpose: Main orchestration engine coordinating rule execution across files and directories
+
+Scope: Central coordination of linting operations integrating registry, config, and ignore systems
+
+Overview: Provides the main entry point for linting operations by coordinating execution of rules
+    across single files and entire directory trees. Integrates with the rule registry for dynamic
+    rule discovery, configuration loader for user settings, ignore directive parser for suppression
+    patterns, and language detector for file routing. Creates lint contexts for each file with
+    appropriate file information and language metadata, executes applicable rules against contexts,
+    and collects violations across all processed files. Supports recursive and non-recursive
+    directory traversal, respects .thailintignore patterns at repository level, and provides
+    configurable linting through .thailint.yaml configuration files. Serves as the primary
+    interface between the linter framework and user-facing CLI/library APIs.
+
+Dependencies: pathlib for file operations, BaseLintRule and BaseLintContext from core.base,
+    Violation from core.types, RuleRegistry from core.registry, LinterConfigLoader from
+    linter_config.loader, IgnoreDirectiveParser from linter_config.ignore, detect_language
+    from language_detector
+
+Exports: Orchestrator class, FileLintContext implementation class
+
+Interfaces: Orchestrator(project_root: Path | None), lint_file(file_path: Path) -> list[Violation],
+    lint_directory(dir_path: Path, recursive: bool) -> list[Violation]
+
+Implementation: Directory glob pattern matching for traversal (** for recursive, * for shallow),
+    ignore pattern checking before file processing, dynamic context creation per file,
+    rule filtering by applicability, violation collection and aggregation across files
+"""
+
+from pathlib import Path
+
+from src.core.base import BaseLintContext, BaseLintRule
+from src.core.registry import RuleRegistry
+from src.core.types import Violation
+from src.linter_config.ignore import IgnoreDirectiveParser
+from src.linter_config.loader import LinterConfigLoader
+
+from .language_detector import detect_language
+
+
+class FileLintContext(BaseLintContext):
+    """Concrete implementation of lint context for file analysis."""
+
+    def __init__(
+        self, path: Path, lang: str, content: str | None = None, metadata: dict | None = None
+    ):
+        """Initialize file lint context.
+
+        Args:
+            path: Path to the file being analyzed.
+            lang: Programming language identifier.
+            content: Optional pre-loaded file content.
+            metadata: Optional metadata dict containing configuration.
+        """
+        self._path = path
+        self._language = lang
+        self._content = content
+        self.metadata = metadata or {}
+
+    @property
+    def file_path(self) -> Path | None:
+        """Get file path being analyzed."""
+        return self._path
+
+    @property
+    def file_content(self) -> str | None:
+        """Get file content being analyzed."""
+        if self._content is not None:
+            return self._content
+        if not self._path or not self._path.exists():
+            return None
+        try:
+            self._content = self._path.read_text(encoding="utf-8")
+        except (UnicodeDecodeError, OSError):
+            self._content = None
+        return self._content
+
+    @property
+    def language(self) -> str:
+        """Get programming language of file."""
+        return self._language
+
+
+class Orchestrator:
+    """Main linter orchestrator coordinating rule execution.
+
+    Integrates rule registry, configuration loading, ignore patterns, and language
+    detection to provide comprehensive linting of files and directories.
+    """
+
+    def __init__(self, project_root: Path | None = None):
+        """Initialize orchestrator.
+
+        Args:
+            project_root: Root directory of project. Defaults to current directory.
+        """
+        self.project_root = project_root or Path.cwd()
+        self.registry = RuleRegistry()
+        self.config_loader = LinterConfigLoader()
+        self.ignore_parser = IgnoreDirectiveParser(self.project_root)
+
+        # 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"
+
+        self.config = self.config_loader.load(config_path)
+
+    def lint_file(self, file_path: Path) -> list[Violation]:
+        """Lint a single file.
+
+        Args:
+            file_path: Path to file to lint.
+
+        Returns:
+            List of violations found in the file.
+        """
+        if self.ignore_parser.is_ignored(file_path):
+            return []
+
+        language = detect_language(file_path)
+        rules = self._get_rules_for_file(file_path, language)
+        context = FileLintContext(file_path, language, metadata=self.config)
+
+        return self._execute_rules(rules, context)
+
+    def _execute_rules(
+        self, rules: list[BaseLintRule], context: BaseLintContext
+    ) -> list[Violation]:
+        """Execute rules and collect violations.
+
+        Args:
+            rules: List of rules to execute.
+            context: Lint context to pass to rules.
+
+        Returns:
+            List of violations found.
+        """
+        violations = []
+        for rule in rules:
+            rule_violations = self._safe_check_rule(rule, context)
+            violations.extend(rule_violations)
+        return violations
+
+    def _safe_check_rule(self, rule: BaseLintRule, context: BaseLintContext) -> list[Violation]:
+        """Safely check a rule, returning empty list on error."""
+        try:
+            return rule.check(context)
+        except Exception:  # nosec B112
+            # Skip rules that fail (defensive programming)
+            return []
+
+    def lint_directory(self, dir_path: Path, recursive: bool = True) -> list[Violation]:
+        """Lint all files in a directory.
+
+        Args:
+            dir_path: Path to directory to lint.
+            recursive: Whether to traverse subdirectories recursively.
+
+        Returns:
+            List of all violations found across all files.
+        """
+        violations = []
+        pattern = "**/*" if recursive else "*"
+
+        for file_path in dir_path.glob(pattern):
+            if file_path.is_file():
+                violations.extend(self.lint_file(file_path))
+
+        return violations
+
+    def _get_rules_for_file(self, file_path: Path, language: str) -> list[BaseLintRule]:
+        """Get rules applicable to this file.
+
+        Args:
+            file_path: Path to file being linted.
+            language: Detected programming language.
+
+        Returns:
+            List of rules to execute against this file.
+        """
+        # For now, return all registered rules
+        # Future: filter by language, configuration, etc.
+        return self.registry.list_all()

src/orchestrator/language_detector.py

@@ -0,0 +1,81 @@
+"""
+Purpose: Programming language detection from file extensions and content
+
+Scope: Language identification for routing files to appropriate analyzers and rules
+
+Overview: Detects programming language from files using multiple strategies including file
+    extension mapping, shebang line parsing for scripts, and content analysis. Provides simple
+    extension-to-language mapping for common file types (.py -> python, .js -> javascript,
+    .ts -> typescript, .java -> java, .go -> go). Falls back to shebang parsing for extensionless
+    scripts by reading first line and checking for language indicators. Returns 'unknown' for
+    unrecognized files, allowing the orchestrator to skip or apply language-agnostic rules.
+    Enables the multi-language architecture by accurately identifying file types for proper
+    rule routing and analyzer selection.
+
+Dependencies: pathlib for file path handling and content reading
+
+Exports: detect_language(file_path: Path) -> str function, EXTENSION_MAP constant
+
+Interfaces: detect_language(file_path: Path) -> str returns language identifier string
+    (python, javascript, typescript, java, go, unknown)
+
+Implementation: Dictionary-based extension lookup for O(1) detection, first-line shebang
+    parsing with substring matching, lazy file reading only when extension unknown
+"""
+
+from pathlib import Path
+
+# Extension to language mapping
+EXTENSION_MAP = {
+    ".py": "python",
+    ".js": "javascript",
+    ".ts": "typescript",
+    ".tsx": "typescript",
+    ".jsx": "javascript",
+    ".java": "java",
+    ".go": "go",
+}
+
+
+def _detect_from_shebang(file_path: Path) -> str | None:
+    """Detect language from shebang line."""
+    try:
+        first_line = _read_first_line(file_path)
+        return _parse_shebang_language(first_line)
+    except (UnicodeDecodeError, OSError):
+        return None
+
+
+def _read_first_line(file_path: Path) -> str:
+    """Read the first line from a file."""
+    return file_path.read_text(encoding="utf-8").split("\n")[0]
+
+
+def _parse_shebang_language(line: str) -> str | None:
+    """Parse language from shebang line."""
+    if not line.startswith("#!"):
+        return None
+    if "python" in line:
+        return "python"
+    return None
+
+
+def detect_language(file_path: Path) -> str:
+    """Detect programming language from file.
+
+    Args:
+        file_path: Path to file to analyze.
+
+    Returns:
+        Language identifier (python, javascript, typescript, java, go, unknown).
+    """
+    ext = file_path.suffix.lower()
+    if ext in EXTENSION_MAP:
+        return EXTENSION_MAP[ext]
+
+    if file_path.exists() and file_path.stat().st_size > 0:
+        lang = _detect_from_shebang(file_path)
+        if lang:
+            return lang
+
+    return "unknown"

thailint-0.1.0.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Steve Jackson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.