thailint 0.2.1__py3-none-any.whl → 0.3.1__py3-none-any.whl

src/cli.py

@@ -1077,5 +1077,106 @@ def _run_dry_lint(orchestrator, path_objs, recursive):
     return dry_violations
 
 
+def _setup_magic_numbers_orchestrator(
+    path_objs: list[Path], config_file: str | None, verbose: bool
+):
+    """Set up orchestrator for magic-numbers command."""
+    first_path = path_objs[0] if path_objs else Path.cwd()
+    project_root = first_path if first_path.is_dir() else first_path.parent
+
+    from src.orchestrator.core import Orchestrator
+
+    orchestrator = Orchestrator(project_root=project_root)
+
+    if config_file:
+        _load_config_file(orchestrator, config_file, verbose)
+
+    return orchestrator
+
+
+def _run_magic_numbers_lint(orchestrator, path_objs: list[Path], recursive: bool):
+    """Execute magic-numbers lint on files or directories."""
+    all_violations = _execute_linting_on_paths(orchestrator, path_objs, recursive)
+    return [v for v in all_violations if "magic-number" in v.rule_id]
+
+
+@cli.command("magic-numbers")
+@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 magic_numbers(  # pylint: disable=too-many-arguments,too-many-positional-arguments
+    ctx,
+    paths: tuple[str, ...],
+    config_file: str | None,
+    format: str,
+    recursive: bool,
+):
+    """Check for magic numbers in code.
+
+    Detects unnamed numeric literals in Python and TypeScript/JavaScript code
+    that should be extracted as named constants for better readability.
+
+    PATHS: Files or directories to lint (defaults to current directory if none provided)
+
+    Examples:
+
+        \b
+        # Check current directory (all files recursively)
+        thai-lint magic-numbers
+
+        \b
+        # Check specific directory
+        thai-lint magic-numbers src/
+
+        \b
+        # Check single file
+        thai-lint magic-numbers src/app.py
+
+        \b
+        # Check multiple files
+        thai-lint magic-numbers src/app.py src/utils.py tests/test_app.py
+
+        \b
+        # Check mix of files and directories
+        thai-lint magic-numbers src/app.py tests/
+
+        \b
+        # Get JSON output
+        thai-lint magic-numbers --format json .
+
+        \b
+        # Use custom config file
+        thai-lint magic-numbers --config .thailint.yaml src/
+    """
+    verbose = ctx.obj.get("verbose", False)
+
+    if not paths:
+        paths = (".",)
+
+    path_objs = [Path(p) for p in paths]
+
+    try:
+        _execute_magic_numbers_lint(path_objs, config_file, format, recursive, verbose)
+    except Exception as e:
+        _handle_linting_error(e, verbose)
+
+
+def _execute_magic_numbers_lint(  # pylint: disable=too-many-arguments,too-many-positional-arguments
+    path_objs, config_file, format, recursive, verbose
+):
+    """Execute magic-numbers lint."""
+    _validate_paths_exist(path_objs)
+    orchestrator = _setup_magic_numbers_orchestrator(path_objs, config_file, verbose)
+    magic_numbers_violations = _run_magic_numbers_lint(orchestrator, path_objs, recursive)
+
+    if verbose:
+        logger.info(f"Found {len(magic_numbers_violations)} magic number violation(s)")
+
+    format_violations(magic_numbers_violations, format)
+    sys.exit(1 if magic_numbers_violations else 0)
+
+
 if __name__ == "__main__":
     cli()

src/config.py

@@ -34,6 +34,10 @@ class ConfigError(Exception):
     """Configuration-related errors."""
 
 
+# Default configuration constants
+DEFAULT_MAX_RETRIES = 3
+DEFAULT_TIMEOUT_SECONDS = 30
+
 # Default configuration values
 DEFAULT_CONFIG: dict[str, Any] = {
     "app_name": "{{PROJECT_NAME}}",
@@ -41,8 +45,8 @@ DEFAULT_CONFIG: dict[str, Any] = {
     "log_level": "INFO",
     "output_format": "text",
     "greeting": "Hello",
-    "max_retries": 3,
-    "timeout": 30,
+    "max_retries": DEFAULT_MAX_RETRIES,
+    "timeout": DEFAULT_TIMEOUT_SECONDS,
 }
 
 # Configuration file search paths (in priority order)

src/core/base.py

@@ -8,14 +8,17 @@ Overview: Establishes the contract that all linting plugins must follow through
     Defines BaseLintRule which all concrete linting rules inherit from, specifying required
     properties (rule_id, rule_name, description) and the check() method for violation detection.
     Provides BaseLintContext as the interface for accessing file information during analysis,
-    exposing file_path, file_content, and language properties. These abstractions enable the
-    rule registry to discover and instantiate rules dynamically without tight coupling, supporting
-    the extensible plugin system where new rules can be added by simply placing them in the
-    appropriate directory structure.
+    exposing file_path, file_content, and language properties. Includes MultiLanguageLintRule
+    intermediate class implementing template method pattern for language dispatch, eliminating
+    code duplication across multi-language linters (nesting, srp, magic_numbers). These
+    abstractions enable the rule registry to discover and instantiate rules dynamically without
+    tight coupling, supporting the extensible plugin system where new rules can be added by
+    simply placing them in the appropriate directory structure.
 
 Dependencies: abc for abstract base class support, pathlib for Path types, Violation from types
 
-Exports: BaseLintRule (abstract rule interface), BaseLintContext (abstract context interface)
+Exports: BaseLintRule (abstract rule interface), BaseLintContext (abstract context interface),
+    MultiLanguageLintRule (template method base for multi-language linters)
 
 Interfaces: BaseLintRule.check(context) -> list[Violation], BaseLintContext properties
     (file_path, file_content, language), all abstract methods must be implemented by subclasses
@@ -26,6 +29,7 @@ Implementation: ABC-based interface definitions with @abstractmethod decorators,
 
 from abc import ABC, abstractmethod
 from pathlib import Path
+from typing import Any
 
 from .types import Violation
 
@@ -132,3 +136,84 @@ class BaseLintRule(ABC):
             List of violations found during finalization. Empty list by default.
         """
         return []
+
+
+class MultiLanguageLintRule(BaseLintRule):
+    """Base class for linting rules that support multiple programming languages.
+
+    Provides language dispatch pattern to eliminate code duplication across multi-language
+    linters. Subclasses implement language-specific checking methods rather than handling
+    dispatch logic themselves.
+
+    Subclasses must implement:
+    - _check_python(context, config) for Python language support
+    - _check_typescript(context, config) for TypeScript/JavaScript support
+    - _load_config(context) for configuration loading
+    """
+
+    def check(self, context: BaseLintContext) -> list[Violation]:
+        """Check for violations with automatic language dispatch.
+
+        Dispatches to language-specific checking methods based on context.language.
+        Handles common patterns like file content validation and config loading.
+
+        Args:
+            context: Lint context with file information
+
+        Returns:
+            List of violations found
+        """
+        from .linter_utils import has_file_content
+
+        if not has_file_content(context):
+            return []
+
+        config = self._load_config(context)
+        if not config.enabled:
+            return []
+
+        if context.language == "python":
+            return self._check_python(context, config)
+
+        if context.language in ("typescript", "javascript"):
+            return self._check_typescript(context, config)
+
+        return []
+
+    @abstractmethod
+    def _load_config(self, context: BaseLintContext) -> Any:
+        """Load configuration from context.
+
+        Args:
+            context: Lint context
+
+        Returns:
+            Configuration object with at minimum an 'enabled' attribute
+        """
+        raise NotImplementedError("Subclasses must implement _load_config")
+
+    @abstractmethod
+    def _check_python(self, context: BaseLintContext, config: Any) -> list[Violation]:
+        """Check Python code for violations.
+
+        Args:
+            context: Lint context with Python file information
+            config: Loaded configuration
+
+        Returns:
+            List of violations found in Python code
+        """
+        raise NotImplementedError("Subclasses must implement _check_python")
+
+    @abstractmethod
+    def _check_typescript(self, context: BaseLintContext, config: Any) -> list[Violation]:
+        """Check TypeScript/JavaScript code for violations.
+
+        Args:
+            context: Lint context with TypeScript/JavaScript file information
+            config: Loaded configuration
+
+        Returns:
+            List of violations found in TypeScript/JavaScript code
+        """
+        raise NotImplementedError("Subclasses must implement _check_typescript")

src/linters/dry/block_filter.py

@@ -23,6 +23,9 @@ from abc import ABC, abstractmethod
 from pathlib import Path
 from typing import Protocol
 
+# Default filter threshold constants
+DEFAULT_KEYWORD_ARG_THRESHOLD = 0.8
+
 
 class CodeBlock(Protocol):
     """Protocol for code blocks (matches cache.CodeBlock)."""
@@ -67,7 +70,7 @@ class KeywordArgumentFilter(BaseBlockFilter):
     These are common in builder patterns and API calls.
     """
 
-    def __init__(self, threshold: float = 0.8):
+    def __init__(self, threshold: float = DEFAULT_KEYWORD_ARG_THRESHOLD):
         """Initialize filter.
 
         Args:
@@ -256,7 +259,7 @@ def create_default_registry() -> BlockFilterRegistry:
     registry = BlockFilterRegistry()
 
     # Register built-in filters
-    registry.register(KeywordArgumentFilter(threshold=0.8))
+    registry.register(KeywordArgumentFilter(threshold=DEFAULT_KEYWORD_ARG_THRESHOLD))
     registry.register(ImportGroupFilter())
 
     return registry

src/linters/dry/cache.py

@@ -1,26 +1,27 @@
 """
-Purpose: SQLite cache manager for DRY linter with mtime-based invalidation
+Purpose: SQLite storage manager for DRY linter duplicate detection
 
-Scope: Code block storage, cache operations, and duplicate detection queries
+Scope: Code block storage and duplicate detection queries
 
-Overview: Implements persistent caching layer for duplicate code detection using SQLite database.
-    Stores code blocks with hash values, file locations, and metadata. Provides mtime-based cache
-    invalidation to detect stale entries. Serves dual purpose as both cache (avoid re-hashing) and
-    hash table (query duplicates across project). Includes indexes for fast hash lookups enabling
-    cross-file duplicate detection with minimal overhead.
+Overview: Implements in-memory or temporary-file SQLite storage for duplicate code detection.
+    Stores code blocks with hash values, file locations, and metadata during a single linter run.
+    Supports both :memory: mode (fast, RAM-only) and tempfile mode (disk-backed for large projects).
+    No persistence between runs - storage is cleared when linter completes. Includes indexes for
+    fast hash lookups enabling cross-file duplicate detection with minimal overhead.
 
-Dependencies: Python sqlite3 module (stdlib), pathlib.Path, dataclasses
+Dependencies: Python sqlite3 module (stdlib), tempfile module (stdlib), pathlib.Path, dataclasses
 
 Exports: CodeBlock dataclass, DRYCache class
 
-Interfaces: DRYCache.__init__, is_fresh, load, save, find_duplicates_by_hash, get_blocks_for_file,
-    add_blocks, cleanup_stale, close
+Interfaces: DRYCache.__init__(storage_mode), add_blocks(file_path, blocks),
+    find_duplicates_by_hash(hash_value), get_duplicate_hashes(), close()
 
 Implementation: SQLite with two tables (files, code_blocks), indexed on hash_value for performance,
-    ACID transactions for reliability, foreign key constraints for data integrity
+    storage_mode determines :memory: vs tempfile location, ACID transactions for reliability
 """
 
 import sqlite3
+import tempfile
 from dataclasses import dataclass
 from pathlib import Path
 
@@ -39,20 +40,32 @@ class CodeBlock:
 
 
 class DRYCache:
-    """SQLite-backed cache for duplicate detection."""
+    """SQLite-backed storage for duplicate detection."""
 
     SCHEMA_VERSION = 1
 
-    def __init__(self, cache_path: Path) -> None:
-        """Initialize cache with SQLite database.
+    def __init__(self, storage_mode: str = "memory") -> None:
+        """Initialize storage with SQLite database.
 
         Args:
-            cache_path: Path to SQLite database file
+            storage_mode: Storage mode - "memory" (default) or "tempfile"
         """
-        # Ensure parent directory exists
-        cache_path.parent.mkdir(parents=True, exist_ok=True)
+        self._storage_mode = storage_mode
+        self._tempfile = None
+
+        # Create SQLite connection based on storage mode
+        if storage_mode == "memory":
+            self.db = sqlite3.connect(":memory:")
+        elif storage_mode == "tempfile":
+            # Create temporary file that auto-deletes on close
+            # pylint: disable=consider-using-with
+            # Justification: tempfile must remain open for SQLite connection lifetime.
+            # It is explicitly closed in close() method when cache is finalized.
+            self._tempfile = tempfile.NamedTemporaryFile(suffix=".db", delete=True)
+            self.db = sqlite3.connect(self._tempfile.name)
+        else:
+            raise ValueError(f"Invalid storage_mode: {storage_mode}")
 
-        self.db = sqlite3.connect(str(cache_path))
         self._query_service = CacheQueryService()
 
         # Create schema
@@ -82,68 +95,24 @@ class DRYCache:
 
         self.db.commit()
 
-    def is_fresh(self, file_path: Path, current_mtime: float) -> bool:
-        """Check if cached data is fresh (mtime matches).
+    def add_blocks(self, file_path: Path, blocks: list[CodeBlock]) -> None:
+        """Add code blocks to storage.
 
         Args:
-            file_path: Path to file
-            current_mtime: Current modification time
-
-        Returns:
-            True if cache is fresh, False if stale or missing
-        """
-        cursor = self.db.execute("SELECT mtime FROM files WHERE file_path = ?", (str(file_path),))
-        row = cursor.fetchone()
-
-        if not row:
-            return False  # Not in cache
-
-        cached_mtime = row[0]
-        return cached_mtime == current_mtime
-
-    def load(self, file_path: Path) -> list[CodeBlock]:
-        """Load cached code blocks for file.
-
-        Args:
-            file_path: Path to file
-
-        Returns:
-            List of CodeBlock instances from cache
+            file_path: Path to source file
+            blocks: List of CodeBlock instances to store
         """
-        cursor = self.db.execute(
-            """SELECT hash_value, start_line, end_line, snippet
-               FROM code_blocks
-               WHERE file_path = ?""",
-            (str(file_path),),
-        )
-
-        blocks = []
-        for hash_val, start, end, snippet in cursor:
-            block = CodeBlock(
-                file_path=file_path,
-                start_line=start,
-                end_line=end,
-                snippet=snippet,
-                hash_value=hash_val,
-            )
-            blocks.append(block)
-
-        return blocks
-
-    def save(self, file_path: Path, mtime: float, blocks: list[CodeBlock]) -> None:
-        """Save code blocks to cache.
-
-        Args:
-            file_path: Path to file
-            mtime: File modification time
-            blocks: List of CodeBlock instances to cache
-        """
-        # Delete old data for this file
-        self.db.execute("DELETE FROM files WHERE file_path = ?", (str(file_path),))
+        if not blocks:
+            return
 
         # Insert file metadata
+        try:
+            mtime = file_path.stat().st_mtime
+        except OSError:
+            mtime = 0.0  # File doesn't exist, use placeholder
+
         self.db.execute(
-            "INSERT INTO files (file_path, mtime, hash_count) VALUES (?, ?, ?)",
+            "INSERT OR REPLACE INTO files (file_path, mtime, hash_count) VALUES (?, ?, ?)",
             (str(file_path), mtime, len(blocks)),
         )
 
@@ -164,23 +133,6 @@ class DRYCache:
 
         self.db.commit()
 
-    def cleanup_stale(self, max_age_days: int) -> None:
-        """Remove cache entries older than max_age_days.
-
-        Args:
-            max_age_days: Maximum age in days for cache entries
-        """
-        # Use parameterized query to prevent SQL injection
-        self.db.execute(
-            """DELETE FROM files
-               WHERE last_scanned < datetime('now', ? || ' days')""",
-            (f"-{max_age_days}",),
-        )
-
-        # Vacuum to reclaim space
-        self.db.execute("VACUUM")
-        self.db.commit()
-
     def find_duplicates_by_hash(self, hash_value: int) -> list[CodeBlock]:
         """Find all code blocks with the given hash value.
 
@@ -214,5 +166,7 @@ class DRYCache:
         return self._query_service.get_duplicate_hashes(self.db)
 
     def close(self) -> None:
-        """Close database connection."""
+        """Close database connection and cleanup tempfile if used."""
         self.db.close()
+        if self._tempfile:
+            self._tempfile.close()

src/linters/dry/config.py

@@ -20,6 +20,10 @@ Implementation: Dataclass with field defaults, __post_init__ validation, and dic
 from dataclasses import dataclass, field
 from typing import Any
 
+# Default configuration constants
+DEFAULT_MIN_DUPLICATE_LINES = 3
+DEFAULT_MIN_DUPLICATE_TOKENS = 30
+
 
 @dataclass
 class DRYConfig:  # pylint: disable=too-many-instance-attributes
@@ -27,14 +31,14 @@ class DRYConfig:  # pylint: disable=too-many-instance-attributes
 
     Note: Pylint too-many-instance-attributes disabled. This is a configuration
     dataclass serving as a data container for related DRY linter settings.
-    All 12 attributes are cohesively related (detection thresholds, language
-    overrides, caching, filtering). Splitting would reduce cohesion and make
+    All attributes are cohesively related (detection thresholds, language
+    overrides, storage mode, filtering). Splitting would reduce cohesion and make
     configuration loading more complex without meaningful benefit.
     """
 
     enabled: bool = False  # Must be explicitly enabled
-    min_duplicate_lines: int = 3
-    min_duplicate_tokens: int = 30
+    min_duplicate_lines: int = DEFAULT_MIN_DUPLICATE_LINES
+    min_duplicate_tokens: int = DEFAULT_MIN_DUPLICATE_TOKENS
     min_occurrences: int = 2  # Minimum occurrences to report (default: 2)
 
     # Language-specific overrides
@@ -42,10 +46,8 @@ class DRYConfig:  # pylint: disable=too-many-instance-attributes
     typescript_min_occurrences: int | None = None
     javascript_min_occurrences: int | None = None
 
-    # Cache settings
-    cache_enabled: bool = True  # ON by default for performance
-    cache_path: str = ".thailint-cache/dry.db"
-    cache_max_age_days: int = 30
+    # Storage settings
+    storage_mode: str = "memory"  # Options: "memory" (default) or "tempfile"
 
     # Ignore patterns
     ignore_patterns: list[str] = field(default_factory=lambda: ["tests/", "__init__.py"])
@@ -70,6 +72,10 @@ class DRYConfig:  # pylint: disable=too-many-instance-attributes
             )
         if self.min_occurrences <= 0:
             raise ValueError(f"min_occurrences must be positive, got {self.min_occurrences}")
+        if self.storage_mode not in ("memory", "tempfile"):
+            raise ValueError(
+                f"storage_mode must be 'memory' or 'tempfile', got '{self.storage_mode}'"
+            )
 
     def get_min_occurrences_for_language(self, language: str) -> int:
         """Get minimum occurrences threshold for a specific language.
@@ -116,15 +122,13 @@ class DRYConfig:  # pylint: disable=too-many-instance-attributes
 
         return cls(
             enabled=config.get("enabled", False),
-            min_duplicate_lines=config.get("min_duplicate_lines", 3),
-            min_duplicate_tokens=config.get("min_duplicate_tokens", 30),
+            min_duplicate_lines=config.get("min_duplicate_lines", DEFAULT_MIN_DUPLICATE_LINES),
+            min_duplicate_tokens=config.get("min_duplicate_tokens", DEFAULT_MIN_DUPLICATE_TOKENS),
             min_occurrences=config.get("min_occurrences", 2),
             python_min_occurrences=python_config.get("min_occurrences"),
             typescript_min_occurrences=typescript_config.get("min_occurrences"),
             javascript_min_occurrences=javascript_config.get("min_occurrences"),
-            cache_enabled=config.get("cache_enabled", True),
-            cache_path=config.get("cache_path", ".thailint-cache/dry.db"),
-            cache_max_age_days=config.get("cache_max_age_days", 30),
+            storage_mode=config.get("storage_mode", "memory"),
             ignore_patterns=config.get("ignore", []),
             filters=filters,
         )