thailint 0.5.0__py3-none-any.whl → 0.8.0__py3-none-any.whl

src/cli.py

@@ -11,7 +11,7 @@ Overview: Provides the main CLI application using Click decorators for command d
 
 Dependencies: click for CLI framework, logging for structured output, pathlib for file paths
 
-Exports: cli (main command group), hello command, config command group, file_placement command, dry command
+Exports: cli (main command group), hello command, config command group, linter commands
 
 Interfaces: Click CLI commands, configuration context via Click ctx, logging integration
 
@@ -38,7 +38,11 @@ logger = logging.getLogger(__name__)
 def format_option(func):
     """Add --format option to a command for output format selection."""
     return click.option(
-        "--format", "-f", type=click.Choice(["text", "json"]), default="text", help="Output format"
+        "--format",
+        "-f",
+        type=click.Choice(["text", "json", "sarif"]),
+        default="text",
+        help="Output format",
     )(func)
 
 
@@ -1661,5 +1665,235 @@ def _execute_print_statements_lint(  # pylint: disable=too-many-arguments,too-ma
     sys.exit(1 if print_statements_violations else 0)
 
 
+# File Header Command Helper Functions
+
+
+def _setup_file_header_orchestrator(
+    path_objs: list[Path], config_file: str | None, verbose: bool, project_root: Path | None = None
+):
+    """Set up orchestrator for file-header command."""
+    from src.orchestrator.core import Orchestrator
+    from src.utils.project_root import get_project_root
+
+    # Use provided project_root or fall back to auto-detection
+    if project_root is None:
+        first_path = path_objs[0] if path_objs else Path.cwd()
+        search_start = first_path if first_path.is_dir() else first_path.parent
+        project_root = get_project_root(search_start)
+
+    orchestrator = Orchestrator(project_root=project_root)
+
+    if config_file:
+        _load_config_file(orchestrator, config_file, verbose)
+
+    return orchestrator
+
+
+def _run_file_header_lint(orchestrator, path_objs: list[Path], recursive: bool):
+    """Execute file-header lint on files or directories."""
+    all_violations = _execute_linting_on_paths(orchestrator, path_objs, recursive)
+    return [v for v in all_violations if "file-header" in v.rule_id]
+
+
+@cli.command("file-header")
+@click.argument("paths", nargs=-1, type=click.Path())
+@click.option("--config", "-c", "config_file", type=click.Path(), help="Path to config file")
+@format_option
+@click.option("--recursive/--no-recursive", default=True, help="Scan directories recursively")
+@click.pass_context
+def file_header(
+    ctx,
+    paths: tuple[str, ...],
+    config_file: str | None,
+    format: str,
+    recursive: bool,
+):
+    """Check file headers for mandatory fields and atemporal language.
+
+    Validates that source files have proper documentation headers containing
+    required fields (Purpose, Scope, Overview, etc.) and don't use temporal
+    language (dates, "currently", "now", etc.).
+
+    Supports Python, TypeScript, JavaScript, Bash, Markdown, and CSS files.
+
+    PATHS: Files or directories to lint (defaults to current directory if none provided)
+
+    Examples:
+
+        \b
+        # Check current directory (all files recursively)
+        thai-lint file-header
+
+        \b
+        # Check specific directory
+        thai-lint file-header src/
+
+        \b
+        # Check single file
+        thai-lint file-header src/cli.py
+
+        \b
+        # Check multiple files
+        thai-lint file-header src/cli.py src/api.py tests/
+
+        \b
+        # Get JSON output
+        thai-lint file-header --format json .
+
+        \b
+        # Get SARIF output for CI/CD integration
+        thai-lint file-header --format sarif src/
+
+        \b
+        # Use custom config file
+        thai-lint file-header --config .thailint.yaml src/
+    """
+    verbose = ctx.obj.get("verbose", False)
+    project_root = _get_project_root_from_context(ctx)
+
+    # Default to current directory if no paths provided
+    if not paths:
+        paths = (".",)
+
+    path_objs = [Path(p) for p in paths]
+
+    try:
+        _execute_file_header_lint(path_objs, config_file, format, recursive, verbose, project_root)
+    except Exception as e:
+        _handle_linting_error(e, verbose)
+
+
+def _execute_file_header_lint(  # pylint: disable=too-many-arguments,too-many-positional-arguments
+    path_objs, config_file, format, recursive, verbose, project_root=None
+):
+    """Execute file-header lint."""
+    _validate_paths_exist(path_objs)
+    orchestrator = _setup_file_header_orchestrator(path_objs, config_file, verbose, project_root)
+    file_header_violations = _run_file_header_lint(orchestrator, path_objs, recursive)
+
+    if verbose:
+        logger.info(f"Found {len(file_header_violations)} file header violation(s)")
+
+    format_violations(file_header_violations, format)
+    sys.exit(1 if file_header_violations else 0)
+
+
+# =============================================================================
+# Method Property Linter Command
+# =============================================================================
+
+
+def _setup_method_property_orchestrator(
+    path_objs: list[Path], config_file: str | None, verbose: bool, project_root: Path | None = None
+):
+    """Set up orchestrator for method-property command."""
+    from src.orchestrator.core import Orchestrator
+    from src.utils.project_root import get_project_root
+
+    if project_root is None:
+        first_path = path_objs[0] if path_objs else Path.cwd()
+        search_start = first_path if first_path.is_dir() else first_path.parent
+        project_root = get_project_root(search_start)
+
+    orchestrator = Orchestrator(project_root=project_root)
+
+    if config_file:
+        _load_config_file(orchestrator, config_file, verbose)
+
+    return orchestrator
+
+
+def _run_method_property_lint(orchestrator, path_objs: list[Path], recursive: bool):
+    """Execute method-property lint on files or directories."""
+    all_violations = _execute_linting_on_paths(orchestrator, path_objs, recursive)
+    return [v for v in all_violations if "method-property" in v.rule_id]
+
+
+@cli.command("method-property")
+@click.argument("paths", nargs=-1, type=click.Path())
+@click.option("--config", "-c", "config_file", type=click.Path(), help="Path to config file")
+@format_option
+@click.option("--recursive/--no-recursive", default=True, help="Scan directories recursively")
+@click.pass_context
+def method_property(
+    ctx,
+    paths: tuple[str, ...],
+    config_file: str | None,
+    format: str,
+    recursive: bool,
+):
+    """Check for methods that should be @property decorators.
+
+    Detects Python methods that could be converted to properties following
+    Pythonic conventions:
+    - Methods returning only self._attribute or self.attribute
+    - get_* prefixed methods (Java-style getters)
+    - Simple computed values with no side effects
+
+    PATHS: Files or directories to lint (defaults to current directory if none provided)
+
+    Examples:
+
+        \b
+        # Check current directory (all files recursively)
+        thai-lint method-property
+
+        \b
+        # Check specific directory
+        thai-lint method-property src/
+
+        \b
+        # Check single file
+        thai-lint method-property src/models.py
+
+        \b
+        # Check multiple files
+        thai-lint method-property src/models.py src/services.py
+
+        \b
+        # Get JSON output
+        thai-lint method-property --format json .
+
+        \b
+        # Get SARIF output for CI/CD integration
+        thai-lint method-property --format sarif src/
+
+        \b
+        # Use custom config file
+        thai-lint method-property --config .thailint.yaml src/
+    """
+    verbose = ctx.obj.get("verbose", False)
+    project_root = _get_project_root_from_context(ctx)
+
+    if not paths:
+        paths = (".",)
+
+    path_objs = [Path(p) for p in paths]
+
+    try:
+        _execute_method_property_lint(
+            path_objs, config_file, format, recursive, verbose, project_root
+        )
+    except Exception as e:
+        _handle_linting_error(e, verbose)
+
+
+def _execute_method_property_lint(  # pylint: disable=too-many-arguments,too-many-positional-arguments
+    path_objs, config_file, format, recursive, verbose, project_root=None
+):
+    """Execute method-property lint."""
+    _validate_paths_exist(path_objs)
+    orchestrator = _setup_method_property_orchestrator(
+        path_objs, config_file, verbose, project_root
+    )
+    method_property_violations = _run_method_property_lint(orchestrator, path_objs, recursive)
+
+    if verbose:
+        logger.info(f"Found {len(method_property_violations)} method-property violation(s)")
+
+    format_violations(method_property_violations, format)
+    sys.exit(1 if method_property_violations else 0)
+
+
 if __name__ == "__main__":
     cli()

src/core/cli_utils.py

@@ -146,10 +146,12 @@ def format_violations(violations: list, output_format: str) -> None:
 
     Args:
         violations: List of violation objects with rule_id, file_path, line, column, message, severity
-        output_format: Output format ("text" or "json")
+        output_format: Output format ("text", "json", or "sarif")
     """
     if output_format == "json":
         _output_json(violations)
+    elif output_format == "sarif":
+        _output_sarif(violations)
     else:
         _output_text(violations)
 
@@ -177,6 +179,19 @@ def _output_json(violations: list) -> None:
     click.echo(json.dumps(output, indent=2))
 
 
+def _output_sarif(violations: list) -> None:
+    """Output violations in SARIF v2.1.0 format.
+
+    Args:
+        violations: List of violation objects
+    """
+    from src.formatters.sarif import SarifFormatter
+
+    formatter = SarifFormatter()
+    sarif_doc = formatter.format(violations)
+    click.echo(json.dumps(sarif_doc, indent=2))
+
+
 def _output_text(violations: list) -> None:
     """Output violations in human-readable text format.
 

src/core/registry.py

@@ -6,7 +6,7 @@ Scope: Dynamic rule management and discovery across all linter plugin packages
 Overview: Implements rule registry that maintains a collection of registered linting rules indexed
     by rule_id. Provides methods to register individual rules, retrieve rules by identifier, list
     all available rules, and discover rules from packages using the RuleDiscovery helper. Enables
-    the extensible plugin architecture by allowing rules to be added dynamically without framework
+    the extensible plugin architecture by allowing dynamic rule registration without framework
     modifications. Validates rule uniqueness and handles registration errors gracefully.
 
 Dependencies: BaseLintRule, RuleDiscovery

src/formatters/__init__.py

@@ -0,0 +1,22 @@
+"""
+Purpose: SARIF formatter package for thai-lint output
+
+Scope: SARIF v2.1.0 formatter implementation and package exports
+
+Overview: Formatters package providing SARIF (Static Analysis Results Interchange Format) v2.1.0
+    output generation from thai-lint Violation objects. Enables integration with GitHub Code
+    Scanning, Azure DevOps, VS Code SARIF Viewer, and other industry-standard CI/CD platforms.
+    Provides the SarifFormatter class for converting violations to SARIF JSON documents.
+
+Dependencies: sarif module for SarifFormatter class
+
+Exports: SarifFormatter class from sarif.py module
+
+Interfaces: from src.formatters.sarif import SarifFormatter
+
+Implementation: Package initialization with SarifFormatter export
+"""
+
+from src.formatters.sarif import SarifFormatter
+
+__all__ = ["SarifFormatter"]

src/formatters/sarif.py

@@ -0,0 +1,202 @@
+"""
+Purpose: SARIF v2.1.0 formatter for converting Violation objects to SARIF JSON documents
+
+Scope: SARIF document generation, tool metadata, result conversion, location mapping
+
+Overview: Implements SarifFormatter class that converts thai-lint Violation objects to SARIF
+    (Static Analysis Results Interchange Format) v2.1.0 compliant JSON documents. Produces
+    output compatible with GitHub Code Scanning, Azure DevOps, VS Code SARIF Viewer, and
+    other industry-standard static analysis tools. Handles proper field mapping including
+    1-indexed column conversion, rule metadata deduplication, and tool versioning.
+
+Dependencies: src (for __version__), src.core.types (Violation, Severity)
+
+Exports: SarifFormatter class with format() method
+
+Interfaces: SarifFormatter.format(violations: list[Violation]) -> dict
+
+Implementation: Converts Violation objects to SARIF structure with proper indexing and metadata
+"""
+
+from typing import Any
+
+from src import __version__
+from src.core.types import Violation
+
+
+class SarifFormatter:
+    """Formats Violation objects as SARIF v2.1.0 JSON documents.
+
+    SARIF (Static Analysis Results Interchange Format) is the OASIS standard
+    for static analysis tool output, enabling integration with GitHub Code
+    Scanning, Azure DevOps, and other CI/CD platforms.
+
+    Attributes:
+        tool_name: Name of the tool in SARIF output (default: "thai-lint")
+        tool_version: Version string for the tool (default: package version)
+        information_uri: URL for tool documentation
+    """
+
+    SARIF_VERSION = "2.1.0"
+    SARIF_SCHEMA = (
+        "https://raw.githubusercontent.com/oasis-tcs/sarif-spec/"
+        "main/sarif-2.1/schema/sarif-schema-2.1.0.json"
+    )
+    DEFAULT_INFORMATION_URI = "https://github.com/be-wise-be-kind/thai-lint"
+
+    def __init__(
+        self,
+        tool_name: str = "thai-lint",
+        tool_version: str | None = None,
+        information_uri: str | None = None,
+    ) -> None:
+        """Initialize SarifFormatter with tool metadata.
+
+        Args:
+            tool_name: Name of the tool (default: "thai-lint")
+            tool_version: Version string (default: package __version__)
+            information_uri: URL for tool documentation
+        """
+        self.tool_name = tool_name
+        self.tool_version = tool_version or __version__
+        self.information_uri = information_uri or self.DEFAULT_INFORMATION_URI
+
+    def format(self, violations: list[Violation]) -> dict[str, Any]:
+        """Convert violations to SARIF v2.1.0 document.
+
+        Args:
+            violations: List of Violation objects to format
+
+        Returns:
+            SARIF v2.1.0 compliant dictionary ready for JSON serialization
+        """
+        return {
+            "version": self.SARIF_VERSION,
+            "$schema": self.SARIF_SCHEMA,
+            "runs": [self._create_run(violations)],
+        }
+
+    def _create_run(self, violations: list[Violation]) -> dict[str, Any]:
+        """Create a SARIF run object containing tool and results.
+
+        Args:
+            violations: List of violations for this run
+
+        Returns:
+            SARIF run object with tool and results
+        """
+        return {
+            "tool": self._create_tool(violations),
+            "results": [self._create_result(v) for v in violations],
+        }
+
+    def _create_tool(self, violations: list[Violation]) -> dict[str, Any]:
+        """Create SARIF tool object with driver metadata.
+
+        Args:
+            violations: List of violations to extract rule metadata from
+
+        Returns:
+            SARIF tool object with driver
+        """
+        return {
+            "driver": {
+                "name": self.tool_name,
+                "version": self.tool_version,
+                "informationUri": self.information_uri,
+                "rules": self._create_rules(violations),
+            }
+        }
+
+    def _create_rules(self, violations: list[Violation]) -> list[dict[str, Any]]:
+        """Create deduplicated SARIF rules array from violations.
+
+        Args:
+            violations: List of violations to extract unique rules from
+
+        Returns:
+            List of SARIF rule objects with unique IDs
+        """
+        seen_rule_ids: set[str] = set()
+        rules: list[dict[str, Any]] = []
+
+        for violation in violations:
+            if violation.rule_id not in seen_rule_ids:
+                seen_rule_ids.add(violation.rule_id)
+                rules.append(self._create_rule(violation))
+
+        return rules
+
+    def _create_rule(self, violation: Violation) -> dict[str, Any]:
+        """Create SARIF rule object from violation.
+
+        Args:
+            violation: Violation to extract rule metadata from
+
+        Returns:
+            SARIF rule object with id and shortDescription
+        """
+        # Extract rule category from rule_id (e.g., "nesting" from "nesting.excessive-depth")
+        parts = violation.rule_id.split(".")
+        category = parts[0] if parts else violation.rule_id
+
+        descriptions: dict[str, str] = {
+            "file-placement": "File placement violation",
+            "nesting": "Nesting depth violation",
+            "srp": "Single Responsibility Principle violation",
+            "dry": "Don't Repeat Yourself violation",
+            "magic-number": "Magic number violation",
+            "magic-numbers": "Magic number violation",
+            "file-header": "File header violation",
+            "print-statements": "Print statement violation",
+        }
+
+        description = descriptions.get(category, f"Rule: {violation.rule_id}")
+
+        return {
+            "id": violation.rule_id,
+            "shortDescription": {
+                "text": description,
+            },
+        }
+
+    def _create_result(self, violation: Violation) -> dict[str, Any]:
+        """Create SARIF result object from violation.
+
+        Args:
+            violation: Violation to convert to SARIF result
+
+        Returns:
+            SARIF result object with ruleId, level, message, locations
+        """
+        # thai-lint uses binary severity (ERROR only), map all to "error" level
+        return {
+            "ruleId": violation.rule_id,
+            "level": "error",
+            "message": {
+                "text": violation.message,
+            },
+            "locations": [self._create_location(violation)],
+        }
+
+    def _create_location(self, violation: Violation) -> dict[str, Any]:
+        """Create SARIF location object from violation.
+
+        Args:
+            violation: Violation with location information
+
+        Returns:
+            SARIF location object with physicalLocation
+        """
+        return {
+            "physicalLocation": {
+                "artifactLocation": {
+                    "uri": violation.file_path,
+                },
+                "region": {
+                    "startLine": violation.line,
+                    # SARIF uses 1-indexed columns, Violation uses 0-indexed
+                    "startColumn": violation.column + 1,
+                },
+            }
+        }

src/linter_config/loader.py

@@ -19,7 +19,7 @@ Dependencies: PyYAML for YAML parsing with safe_load(), json (stdlib) for JSON p
 Exports: LinterConfigLoader class
 
 Interfaces: load(config_path: Path) -> dict[str, Any] for loading config files,
-    get_defaults() -> dict[str, Any] for default configuration structure
+    defaults property -> dict[str, Any] for default configuration structure
 
 Implementation: Extension-based format detection (.yaml/.yml vs .json), yaml.safe_load()
     for security, empty dict handling for null YAML, ValueError for unsupported formats
@@ -51,12 +51,13 @@ class LinterConfigLoader:
             ConfigParseError: If file format is unsupported or parsing fails.
         """
         if not config_path.exists():
-            return self.get_defaults()
+            return self.defaults
 
         return parse_config_file(config_path)
 
-    def get_defaults(self) -> dict[str, Any]:
-        """Get default configuration.
+    @property
+    def defaults(self) -> dict[str, Any]:
+        """Default configuration.
 
         Returns:
             Default configuration with empty rules and ignore lists.

src/linters/dry/block_filter.py

@@ -53,9 +53,10 @@ class BaseBlockFilter(ABC):
         """
         pass
 
+    @property
     @abstractmethod
-    def get_name(self) -> str:
-        """Get filter name for configuration and logging."""
+    def name(self) -> str:
+        """Filter name for configuration and logging."""
         pass
 
 
@@ -152,8 +153,9 @@ class KeywordArgumentFilter(BaseBlockFilter):
             return False
         return True
 
-    def get_name(self) -> str:
-        """Get filter name."""
+    @property
+    def name(self) -> str:
+        """Filter name."""
         return "keyword_argument_filter"
 
 
@@ -184,8 +186,9 @@ class ImportGroupFilter(BaseBlockFilter):
 
         return True
 
-    def get_name(self) -> str:
-        """Get filter name."""
+    @property
+    def name(self) -> str:
+        """Filter name."""
         return "import_group_filter"
 
 
@@ -204,7 +207,7 @@ class BlockFilterRegistry:
             filter_instance: Filter to register
         """
         self._filters.append(filter_instance)
-        self._enabled_filters.add(filter_instance.get_name())
+        self._enabled_filters.add(filter_instance.name)
 
     def enable_filter(self, filter_name: str) -> None:
         """Enable a specific filter by name.
@@ -233,7 +236,7 @@ class BlockFilterRegistry:
             True if block should be filtered out
         """
         for filter_instance in self._filters:
-            if filter_instance.get_name() not in self._enabled_filters:
+            if filter_instance.name not in self._enabled_filters:
                 continue
 
             if filter_instance.should_filter(block, file_content):

src/linters/dry/cache.py

@@ -157,8 +157,9 @@ class DRYCache:
 
         return blocks
 
-    def get_duplicate_hashes(self) -> list[int]:
-        """Get all hash values that appear 2+ times.
+    @property
+    def duplicate_hashes(self) -> list[int]:
+        """Hash values that appear 2+ times.
 
         Returns:
             List of hash values with 2 or more occurrences

src/linters/dry/duplicate_storage.py

@@ -11,7 +11,7 @@ Dependencies: DRYCache, CodeBlock, Path
 
 Exports: DuplicateStorage class
 
-Interfaces: DuplicateStorage.add_blocks(file_path, blocks), get_duplicate_hashes(),
+Interfaces: DuplicateStorage.add_blocks(file_path, blocks), duplicate_hashes property,
     get_blocks_for_hash(hash_value)
 
 Implementation: Delegates to SQLite cache for all storage operations
@@ -43,13 +43,14 @@ class DuplicateStorage:
         if blocks:
             self._cache.add_blocks(file_path, blocks)
 
-    def get_duplicate_hashes(self) -> list[int]:
-        """Get all hash values with 2+ occurrences from SQLite.
+    @property
+    def duplicate_hashes(self) -> list[int]:
+        """Hash values with 2+ occurrences from SQLite.
 
         Returns:
             List of hash values that appear in multiple blocks
         """
-        return self._cache.get_duplicate_hashes()
+        return self._cache.duplicate_hashes
 
     def get_blocks_for_hash(self, hash_value: int) -> list[CodeBlock]:
         """Get all blocks with given hash value from SQLite.

src/linters/dry/violation_generator.py

@@ -55,7 +55,7 @@ class ViolationGenerator:
         Returns:
             List of violations filtered by ignore patterns and inline directives
         """
-        duplicate_hashes = storage.get_duplicate_hashes()
+        duplicate_hashes = storage.duplicate_hashes
         violations = []
 
         for hash_value in duplicate_hashes: