thailint 0.7.0__tar.gz → 0.8.0__tar.gz

{thailint-0.7.0 → thailint-0.8.0}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: thailint
-Version: 0.7.0
+Version: 0.8.0
 Summary: The AI Linter - Enterprise-grade linting and governance for AI-generated code across multiple languages
 License: MIT
 License-File: LICENSE
 Keywords: linter,ai,code-quality,static-analysis,file-placement,governance,multi-language,cli,docker,python
 Author: Steve Jackson
 Requires-Python: >=3.11,<4.0
-Classifier: Development Status :: 3 - Alpha
+Classifier: Development Status :: 4 - Beta
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
@@ -37,7 +37,7 @@ Description-Content-Type: text/markdown
 
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 [![Python 3.11+](https://img.shields.io/badge/python-3.11+-blue.svg)](https://www.python.org/downloads/)
-[![Tests](https://img.shields.io/badge/tests-571%2F571%20passing-brightgreen.svg)](tests/)
+[![Tests](https://img.shields.io/badge/tests-682%2F682%20passing-brightgreen.svg)](tests/)
 [![Coverage](https://img.shields.io/badge/coverage-87%25-brightgreen.svg)](htmlcov/)
 [![Documentation Status](https://readthedocs.org/projects/thai-lint/badge/?version=latest)](https://thai-lint.readthedocs.io/en/latest/?badge=latest)
 [![SARIF 2.1.0](https://img.shields.io/badge/SARIF-2.1.0-orange.svg)](docs/sarif-output.md)
@@ -98,6 +98,12 @@ thailint complements your existing linting stack by catching the patterns AI too
   - Configurable thresholds (lines, tokens, occurrences)
   - Language-specific detection (Python, TypeScript, JavaScript)
   - False positive filtering (keyword args, imports)
+- **Method Property Linting** - Detect methods that should be @property decorators
+  - Python AST-based detection
+  - get_* prefix detection (Java-style getters)
+  - Simple computed value detection
+  - Action verb exclusion (to_*, finalize, serialize)
+  - Test file detection
 - **Pluggable Architecture** - Easy to extend with custom linters
 - **Multi-Language Support** - Python, TypeScript, JavaScript, and more
 - **Flexible Configuration** - YAML/JSON configs with pattern matching

{thailint-0.7.0 → thailint-0.8.0}/README.md

@@ -2,7 +2,7 @@
 
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 [![Python 3.11+](https://img.shields.io/badge/python-3.11+-blue.svg)](https://www.python.org/downloads/)
-[![Tests](https://img.shields.io/badge/tests-571%2F571%20passing-brightgreen.svg)](tests/)
+[![Tests](https://img.shields.io/badge/tests-682%2F682%20passing-brightgreen.svg)](tests/)
 [![Coverage](https://img.shields.io/badge/coverage-87%25-brightgreen.svg)](htmlcov/)
 [![Documentation Status](https://readthedocs.org/projects/thai-lint/badge/?version=latest)](https://thai-lint.readthedocs.io/en/latest/?badge=latest)
 [![SARIF 2.1.0](https://img.shields.io/badge/SARIF-2.1.0-orange.svg)](docs/sarif-output.md)
@@ -63,6 +63,12 @@ thailint complements your existing linting stack by catching the patterns AI too
   - Configurable thresholds (lines, tokens, occurrences)
   - Language-specific detection (Python, TypeScript, JavaScript)
   - False positive filtering (keyword args, imports)
+- **Method Property Linting** - Detect methods that should be @property decorators
+  - Python AST-based detection
+  - get_* prefix detection (Java-style getters)
+  - Simple computed value detection
+  - Action verb exclusion (to_*, finalize, serialize)
+  - Test file detection
 - **Pluggable Architecture** - Easy to extend with custom linters
 - **Multi-Language Support** - Python, TypeScript, JavaScript, and more
 - **Flexible Configuration** - YAML/JSON configs with pattern matching

{thailint-0.7.0 → thailint-0.8.0}/pyproject.toml

@@ -17,7 +17,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "thailint"
-version = "0.7.0"
+version = "0.8.0"
 description = "The AI Linter - Enterprise-grade linting and governance for AI-generated code across multiple languages"
 authors = ["Steve Jackson"]
 license = "MIT"
@@ -38,7 +38,7 @@ keywords = [
     "python",
 ]
 classifiers = [
-    "Development Status :: 3 - Alpha",
+    "Development Status :: 4 - Beta",
     "Intended Audience :: Developers",
     "License :: OSI Approved :: MIT License",
     "Programming Language :: Python :: 3",

{thailint-0.7.0 → thailint-0.8.0}/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
 
@@ -1778,5 +1778,122 @@ def _execute_file_header_lint(  # pylint: disable=too-many-arguments,too-many-po
     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()

{thailint-0.7.0 → thailint-0.8.0}/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.

{thailint-0.7.0 → thailint-0.8.0}/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):

{thailint-0.7.0 → thailint-0.8.0}/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

{thailint-0.7.0 → thailint-0.8.0}/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.

{thailint-0.7.0 → thailint-0.8.0}/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:

thailint-0.8.0/src/linters/method_property/__init__.py

@@ -0,0 +1,49 @@
+"""
+Purpose: Package exports for method-should-be-property linter
+
+Scope: Method property linter public API
+
+Overview: Exports the MethodPropertyRule class and MethodPropertyConfig dataclass for use by
+    the orchestrator and external consumers. Provides a convenience lint() function for
+    standalone usage of the linter.
+
+Dependencies: MethodPropertyRule from linter module, MethodPropertyConfig from config module
+
+Exports: MethodPropertyRule, MethodPropertyConfig, lint function
+
+Interfaces: lint(file_path, content, config) -> list[Violation] convenience function
+
+Implementation: Simple re-exports from submodules with optional convenience wrapper
+"""
+
+from .config import MethodPropertyConfig
+from .linter import MethodPropertyRule
+
+__all__ = ["MethodPropertyRule", "MethodPropertyConfig", "lint"]
+
+
+def lint(
+    file_path: str,
+    content: str,
+    config: dict | None = None,
+) -> list:
+    """Lint a file for method-should-be-property violations.
+
+    Args:
+        file_path: Path to the file being linted
+        content: Content of the file
+        config: Optional configuration dictionary
+
+    Returns:
+        List of Violation objects
+    """
+    from unittest.mock import Mock
+
+    rule = MethodPropertyRule()
+    context = Mock()
+    context.file_path = file_path
+    context.file_content = content
+    context.language = "python"
+    context.config = config
+
+    return rule.check(context)

thailint-0.8.0/src/linters/method_property/config.py

@@ -0,0 +1,135 @@
+"""
+Purpose: Configuration schema for method-should-be-property linter
+
+Scope: Method property linter configuration for Python files
+
+Overview: Defines configuration schema for method-should-be-property linter. Provides
+    MethodPropertyConfig dataclass with enabled flag, max_body_statements threshold (default 3)
+    for determining when a method body is too complex to be a property candidate, and ignore
+    patterns list for excluding specific files or directories. Includes configurable action verb
+    exclusions (prefixes and names) with sensible defaults that can be extended or overridden.
+    Supports per-file and per-directory config overrides through from_dict class method.
+    Integrates with orchestrator's configuration system via .thailint.yaml.
+
+Dependencies: dataclasses module for configuration structure, typing module for type hints
+
+Exports: MethodPropertyConfig dataclass, DEFAULT_EXCLUDE_PREFIXES, DEFAULT_EXCLUDE_NAMES
+
+Interfaces: from_dict(config, language) -> MethodPropertyConfig for configuration loading
+
+Implementation: Dataclass with defaults matching Pythonic conventions and common use cases
+"""
+
+from dataclasses import dataclass, field
+from typing import Any
+
+# Default action verb prefixes - methods starting with these are excluded
+# These represent actions/transformations, not property access
+DEFAULT_EXCLUDE_PREFIXES: tuple[str, ...] = (
+    "to_",  # Transformation: to_dict, to_json, to_string
+    "dump_",  # Serialization: dump_to_json, dump_to_apigw
+    "generate_",  # Factory: generate_report, generate_html
+    "create_",  # Factory: create_instance, create_config
+    "build_",  # Construction: build_query, build_html
+    "make_",  # Factory: make_request, make_connection
+    "render_",  # Output: render_template, render_html
+    "compute_",  # Calculation: compute_hash, compute_total
+    "calculate_",  # Calculation: calculate_sum, calculate_average
+)
+
+# Default action verb names - exact method names that are excluded
+# These are lifecycle hooks, display actions, and resource operations
+DEFAULT_EXCLUDE_NAMES: frozenset[str] = frozenset(
+    {
+        "finalize",  # Lifecycle hook
+        "serialize",  # Transformation
+        "dump",  # Serialization
+        "validate",  # Validation action
+        "show",  # Display action
+        "display",  # Display action
+        "print",  # Output action
+        "refresh",  # Update action
+        "reset",  # State action
+        "clear",  # State action
+        "close",  # Resource action
+        "open",  # Resource action
+        "save",  # Persistence action
+        "load",  # Persistence action
+        "execute",  # Action
+        "run",  # Action
+    }
+)
+
+
+def _load_list_config(
+    config: dict[str, Any], key: str, override_key: str, default: tuple[str, ...]
+) -> tuple[str, ...]:
+    """Load a list config with extend/override semantics."""
+    if override_key in config and isinstance(config[override_key], list):
+        return tuple(config[override_key])
+    if key in config and isinstance(config[key], list):
+        return default + tuple(config[key])
+    return default
+
+
+def _load_set_config(
+    config: dict[str, Any], key: str, override_key: str, default: frozenset[str]
+) -> frozenset[str]:
+    """Load a set config with extend/override semantics."""
+    if override_key in config and isinstance(config[override_key], list):
+        return frozenset(config[override_key])
+    if key in config and isinstance(config[key], list):
+        return default | frozenset(config[key])
+    return default
+
+
+@dataclass
+class MethodPropertyConfig:  # thailint: ignore[dry]
+    """Configuration for method-should-be-property linter."""
+
+    enabled: bool = True
+    max_body_statements: int = 3
+    ignore: list[str] = field(default_factory=list)
+    ignore_methods: list[str] = field(default_factory=list)
+
+    # Action verb exclusions (extend defaults or override)
+    exclude_prefixes: tuple[str, ...] = DEFAULT_EXCLUDE_PREFIXES
+    exclude_names: frozenset[str] = DEFAULT_EXCLUDE_NAMES
+
+    # dry: ignore-block
+    @classmethod
+    def from_dict(
+        cls, config: dict[str, Any] | None, language: str | None = None
+    ) -> "MethodPropertyConfig":
+        """Load configuration from dictionary.
+
+        Args:
+            config: Dictionary containing configuration values, or None
+            language: Programming language (unused, for interface compatibility)
+
+        Returns:
+            MethodPropertyConfig instance with values from dictionary
+        """
+        if config is None:
+            return cls()
+
+        ignore_patterns = config.get("ignore", [])
+        if not isinstance(ignore_patterns, list):
+            ignore_patterns = []
+
+        ignore_methods = config.get("ignore_methods", [])
+        if not isinstance(ignore_methods, list):
+            ignore_methods = []
+
+        return cls(
+            enabled=config.get("enabled", True),
+            max_body_statements=config.get("max_body_statements", 3),
+            ignore=ignore_patterns,
+            ignore_methods=ignore_methods,
+            exclude_prefixes=_load_list_config(
+                config, "exclude_prefixes", "exclude_prefixes_override", DEFAULT_EXCLUDE_PREFIXES
+            ),
+            exclude_names=_load_set_config(
+                config, "exclude_names", "exclude_names_override", DEFAULT_EXCLUDE_NAMES
+            ),
+        )