thailint 0.11.0__py3-none-any.whl → 0.13.0__py3-none-any.whl

src/cli/linters/code_smells.py

@@ -1,18 +1,18 @@
 """
-Purpose: CLI commands for code smell linters (dry, magic-numbers)
+Purpose: CLI commands for code smell linters (dry, magic-numbers, stringly-typed)
 
-Scope: Commands that detect code smells like duplicate code and magic numbers
+Scope: Commands that detect code smells like duplicate code, magic numbers, and stringly-typed patterns
 
 Overview: Provides CLI commands for code smell detection: dry finds duplicate code blocks using
-    token-based hashing with SQLite caching, and magic-numbers detects unnamed numeric literals that
-    should be extracted as named constants. Each command supports standard options (config, format,
-    recursive) plus linter-specific options (min-lines, no-cache, clear-cache) and integrates with
-    the orchestrator for execution.
+    token-based hashing with SQLite caching, magic-numbers detects unnamed numeric literals that
+    should be extracted as named constants, and stringly-typed detects string patterns that should
+    use enums. Each command supports standard options (config, format, recursive) plus linter-specific
+    options and integrates with the orchestrator for execution.
 
 Dependencies: click for CLI framework, src.cli.main for CLI group, src.cli.utils for shared utilities,
     src.cli.linters.shared for linter-specific helpers, yaml for config loading
 
-Exports: dry command, magic_numbers command
+Exports: dry command, magic_numbers command, stringly_typed command
 
 Interfaces: Click CLI commands registered to main CLI group
 
@@ -20,6 +20,10 @@ Implementation: Click decorators for command definition, orchestrator-based lint
 
 SRP Exception: CLI command modules follow Click framework patterns requiring similar command
     structure across all linter commands. This is intentional design for consistency.
+
+Suppressions:
+    too-many-arguments: Click commands require many parameters by framework design
+    too-many-positional-arguments: Click positional params match CLI arg structure
 """
 # dry: ignore-block - CLI commands follow Click framework pattern with intentional repetition
 
@@ -341,3 +345,110 @@ def _execute_magic_numbers_lint(  # pylint: disable=too-many-arguments,too-many-
 
     format_violations(magic_numbers_violations, format)
     sys.exit(1 if magic_numbers_violations else 0)
+
+
+# =============================================================================
+# Stringly-Typed Command
+# =============================================================================
+
+
+def _setup_stringly_typed_orchestrator(
+    path_objs: list[Path], config_file: str | None, verbose: bool, project_root: Path | None = None
+) -> "Orchestrator":
+    """Set up orchestrator for stringly-typed command."""
+    return setup_base_orchestrator(path_objs, config_file, verbose, project_root)
+
+
+def _run_stringly_typed_lint(
+    orchestrator: "Orchestrator", path_objs: list[Path], recursive: bool
+) -> list[Violation]:
+    """Execute stringly-typed lint on files or directories."""
+    all_violations = execute_linting_on_paths(orchestrator, path_objs, recursive)
+    return [v for v in all_violations if "stringly-typed" in v.rule_id]
+
+
+@cli.command("stringly-typed")
+@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 stringly_typed(  # pylint: disable=too-many-arguments,too-many-positional-arguments
+    ctx: click.Context,
+    paths: tuple[str, ...],
+    config_file: str | None,
+    format: str,
+    recursive: bool,
+) -> None:
+    """Check for stringly-typed patterns in code.
+
+    Detects string patterns in Python and TypeScript/JavaScript code that should
+    use enums or typed alternatives. Finds membership validation, equality chains,
+    and function calls with limited string values across multiple files.
+
+    PATHS: Files or directories to lint (defaults to current directory if none provided)
+
+    Examples:
+
+        \b
+        # Check current directory (all files recursively)
+        thai-lint stringly-typed
+
+        \b
+        # Check specific directory
+        thai-lint stringly-typed src/
+
+        \b
+        # Check single file
+        thai-lint stringly-typed src/handlers.py
+
+        \b
+        # Check multiple files
+        thai-lint stringly-typed src/handlers.py src/services.py
+
+        \b
+        # Get JSON output
+        thai-lint stringly-typed --format json .
+
+        \b
+        # Get SARIF output for IDE integration
+        thai-lint stringly-typed --format sarif .
+
+        \b
+        # Use custom config file
+        thai-lint stringly-typed --config .thailint.yaml src/
+    """
+    verbose: bool = 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_stringly_typed_lint(
+            path_objs, config_file, format, recursive, verbose, project_root
+        )
+    except Exception as e:
+        handle_linting_error(e, verbose)
+
+
+def _execute_stringly_typed_lint(  # pylint: disable=too-many-arguments,too-many-positional-arguments
+    path_objs: list[Path],
+    config_file: str | None,
+    format: str,
+    recursive: bool,
+    verbose: bool,
+    project_root: Path | None = None,
+) -> NoReturn:
+    """Execute stringly-typed lint."""
+    validate_paths_exist(path_objs)
+    orchestrator = _setup_stringly_typed_orchestrator(path_objs, config_file, verbose, project_root)
+    stringly_violations = _run_stringly_typed_lint(orchestrator, path_objs, recursive)
+
+    if verbose:
+        logger.info(f"Found {len(stringly_violations)} stringly-typed violation(s)")
+
+    format_violations(stringly_violations, format)
+    sys.exit(1 if stringly_violations else 0)

src/cli/linters/documentation.py

@@ -19,6 +19,9 @@ Implementation: Click decorators for command definition, orchestrator-based lint
 
 SRP Exception: CLI command modules follow Click framework patterns requiring similar command
     structure across all linter commands. This is intentional design for consistency.
+
+Suppressions:
+    - too-many-arguments,too-many-positional-arguments: Click commands require many parameters by framework design
 """
 # dry: ignore-block - CLI commands follow Click framework pattern with intentional repetition
 

src/cli/linters/structure.py

@@ -19,6 +19,9 @@ Implementation: Click decorators for command definition, orchestrator-based lint
 
 SRP Exception: CLI command modules follow Click framework patterns requiring similar command
     structure across all linter commands. This is intentional design for consistency.
+
+Suppressions:
+    - too-many-arguments,too-many-positional-arguments: Click commands require many parameters by framework design
 """
 # dry: ignore-block - CLI commands follow Click framework pattern with intentional repetition
 

src/cli/linters/structure_quality.py

@@ -19,6 +19,9 @@ Implementation: Click decorators for command definition, orchestrator-based lint
 
 SRP Exception: CLI command modules follow Click framework patterns requiring similar command
     structure across all linter commands. This is intentional design for consistency.
+
+Suppressions:
+    - too-many-arguments,too-many-positional-arguments: Click commands require many parameters by framework design
 """
 # dry: ignore-block - CLI commands follow Click framework pattern with intentional repetition
 

src/cli/utils.py

@@ -172,34 +172,54 @@ def _autodetect_project_root(
     return auto_root
 
 
-def get_project_root_from_context(ctx: click.Context) -> Path:
+def get_project_root_from_context(ctx: click.Context) -> Path | None:
     """Get or determine project root from Click context.
 
     This function defers the actual determination until needed to avoid
     importing pyprojroot in test environments where it may not be available.
 
+    Returns None when no explicit root is specified (via --project-root or --config),
+    allowing the orchestrator to auto-detect from target paths instead of CWD.
+
     Args:
         ctx: Click context containing CLI options
 
     Returns:
-        Path to determined project root
+        Path to determined project root, or None for auto-detection from target paths
     """
     # Check if already determined and cached
     if "project_root" in ctx.obj:
-        cached_root: Path = ctx.obj["project_root"]
-        return cached_root
+        cached: Path | None = ctx.obj["project_root"]
+        return cached
+
+    project_root = _determine_project_root_for_context(ctx)
+    ctx.obj["project_root"] = project_root
+    return project_root
+
+
+def _determine_project_root_for_context(ctx: click.Context) -> Path | None:
+    """Determine project root from context options.
+
+    Args:
+        ctx: Click context containing CLI options
 
-    # Determine project root using stored CLI options
+    Returns:
+        Path if explicit root or config specified, None for auto-detection
+    """
     explicit_root = ctx.obj.get("cli_project_root")
     config_path = ctx.obj.get("cli_config_path")
     verbose = ctx.obj.get("verbose", False)
 
-    project_root = _determine_project_root(explicit_root, config_path, verbose)
+    if explicit_root:
+        return _resolve_explicit_project_root(explicit_root, verbose)
 
-    # Cache for future use
-    ctx.obj["project_root"] = project_root
+    if config_path:
+        return _infer_root_from_config(config_path, verbose)
 
-    return project_root
+    # No explicit root - return None for auto-detection from target paths
+    if verbose:
+        logger.debug("No explicit project root, will auto-detect from target paths")
+    return None
 
 
 # =============================================================================

src/cli_main.py

@@ -17,6 +17,9 @@ Exports: cli (main command group with all commands registered)
 Interfaces: Click CLI commands, integration with Orchestrator for linting execution
 
 Implementation: Module imports trigger command registration via Click decorator side effects
+
+Suppressions:
+    - F401: Module re-exports and imports trigger Click command registration via decorator side effects
 """
 
 # Import the main CLI group from the modular package

src/config.py

@@ -26,6 +26,7 @@ from typing import Any
 import yaml
 
 from src.core.config_parser import ConfigParseError, parse_config_file
+from src.core.constants import CONFIG_EXTENSIONS
 
 logger = logging.getLogger(__name__)
 
@@ -170,7 +171,7 @@ def _validate_before_save(config: dict[str, Any]) -> None:
 
 def _write_config_file(config: dict[str, Any], path: Path) -> None:
     """Write config to file based on extension."""
-    if path.suffix in [".yaml", ".yml"]:
+    if path.suffix in CONFIG_EXTENSIONS:
         _write_yaml_config(config, path)
     elif path.suffix == ".json":
         _write_json_config(config, path)

src/core/base.py

@@ -31,6 +31,7 @@ from abc import ABC, abstractmethod
 from pathlib import Path
 from typing import Any
 
+from .constants import Language
 from .types import Violation
 
 
@@ -176,10 +177,10 @@ class MultiLanguageLintRule(BaseLintRule):
         if not config.enabled:
             return []
 
-        if context.language == "python":
+        if context.language == Language.PYTHON:
             return self._check_python(context, config)
 
-        if context.language in ("typescript", "javascript"):
+        if context.language in (Language.TYPESCRIPT, Language.JAVASCRIPT):
             return self._check_typescript(context, config)
 
         return []

src/core/cli_utils.py

@@ -26,6 +26,8 @@ from typing import Any
 
 import click
 
+from src.core.constants import CONFIG_EXTENSIONS
+
 
 def common_linter_options(func: Callable) -> Callable:
     """Add common linter CLI options to command.
@@ -103,7 +105,7 @@ def _load_config_by_format(config_file: Path) -> dict[str, Any]:
     Returns:
         Loaded configuration dictionary
     """
-    if config_file.suffix in {".yaml", ".yml"}:
+    if config_file.suffix in CONFIG_EXTENSIONS:
         return _load_yaml_config(config_file)
     if config_file.suffix == ".json":
         return _load_json_config(config_file)

src/core/config_parser.py

@@ -27,6 +27,8 @@ from typing import Any, TextIO
 
 import yaml
 
+from src.core.constants import CONFIG_EXTENSIONS
+
 
 class ConfigParseError(Exception):
     """Configuration file parsing errors."""
@@ -113,11 +115,12 @@ def parse_config_file(path: Path, encoding: str = "utf-8") -> dict[str, Any]:
     """
     suffix = path.suffix.lower()
 
-    if suffix not in [".yaml", ".yml", ".json"]:
+    valid_suffixes = (*CONFIG_EXTENSIONS, ".json")
+    if suffix not in valid_suffixes:
         raise ConfigParseError(f"Unsupported config format: {suffix}")
 
     with path.open(encoding=encoding) as f:
-        if suffix in [".yaml", ".yml"]:
+        if suffix in CONFIG_EXTENSIONS:
             config = parse_yaml(f, path)
         else:
             config = parse_json(f, path)

src/core/constants.py

@@ -0,0 +1,54 @@
+"""
+Purpose: Core constants and enums used across the thai-lint codebase
+
+Scope: Centralized definitions for language names, storage modes, config extensions
+
+Overview: Provides type-safe enums and constants for consistent stringly-typed patterns
+    across the codebase. Includes Language enum for programming language detection,
+    StorageMode for cache storage options, and CONFIG_EXTENSIONS for config file
+    discovery. Using enums ensures compile-time safety and IDE autocompletion.
+
+Dependencies: enum module
+
+Exports: Language enum, StorageMode enum, CONFIG_EXTENSIONS, IgnoreDirective enum,
+    HEADER_SCAN_LINES, MAX_ATTRIBUTE_CHAIN_DEPTH
+
+Interfaces: Use enum values instead of string literals throughout codebase
+
+Implementation: Standard Python enums with string values for compatibility
+"""
+
+from enum import Enum
+
+
+class Language(str, Enum):
+    """Supported programming languages for linting."""
+
+    PYTHON = "python"
+    TYPESCRIPT = "typescript"
+    JAVASCRIPT = "javascript"
+    MARKDOWN = "markdown"
+
+
+class StorageMode(str, Enum):
+    """Storage modes for DRY linter cache."""
+
+    MEMORY = "memory"
+    TEMPFILE = "tempfile"
+
+
+class IgnoreDirective(str, Enum):
+    """Inline ignore directive types."""
+
+    IGNORE = "ignore"
+    IGNORE_FILE = "ignore-file"
+
+
+# Valid config file extensions
+CONFIG_EXTENSIONS: tuple[str, str] = (".yaml", ".yml")
+
+# Number of lines to scan at file start for ignore directives and headers
+HEADER_SCAN_LINES: int = 10
+
+# Maximum depth for attribute chain traversal (e.g., obj.attr.attr2.attr3)
+MAX_ATTRIBUTE_CHAIN_DEPTH: int = 3

src/core/linter_utils.py

@@ -16,6 +16,10 @@ Exports: get_metadata, get_metadata_value, load_linter_config, has_file_content
 Interfaces: All functions take BaseLintContext and return typed values (dict, str, bool, Any)
 
 Implementation: Type-safe metadata access with fallbacks, generic config loading with language support
+
+Suppressions:
+    - invalid-name: T type variable follows Python generic naming convention
+    - type:ignore[return-value]: Generic config factory with runtime type checking
 """
 
 from typing import Any, Protocol, TypeVar

src/core/rule_discovery.py

@@ -19,12 +19,15 @@ Implementation: Package traversal with pkgutil, class introspection with inspect
 
 import importlib
 import inspect
+import logging
 import pkgutil
 from types import ModuleType
 from typing import Any
 
 from .base import BaseLintRule
 
+logger = logging.getLogger(__name__)
+
 
 def discover_from_package(package_path: str) -> list[BaseLintRule]:
     """Discover rules from a package and its modules.
@@ -37,7 +40,8 @@ def discover_from_package(package_path: str) -> list[BaseLintRule]:
     """
     try:
         package = importlib.import_module(package_path)
-    except ImportError:
+    except ImportError as e:
+        logger.debug("Failed to import package %s: %s", package_path, e)
         return []
 
     if not hasattr(package, "__path__"):

src/core/violation_builder.py

@@ -21,6 +21,9 @@ Interfaces: ViolationInfo(rule_id, file_path, line, message, column, severity),
 
 Implementation: Uses dataclass for type-safe violation info, functions provide build logic
     that constructs Violation objects with proper defaults
+
+Suppressions:
+    - too-many-arguments,too-many-positional-arguments: Violation fields as parameters
 """
 
 from dataclasses import dataclass

src/linter_config/directive_markers.py

@@ -0,0 +1,109 @@
+"""
+Purpose: Ignore directive marker detection for thailint comments
+
+Scope: Detection of thailint and design-lint ignore markers in source code
+
+Overview: Provides functions for detecting various ignore directive markers in code
+    comments. Supports file-level ignores, line-level ignores, block ignores, and
+    next-line ignores. Works with both Python (#) and JavaScript (//) comment styles.
+    All checks are case-insensitive.
+
+Dependencies: None (pure string operations)
+
+Exports: Marker detection functions for various ignore directive types
+
+Interfaces: has_*_marker(line) -> bool for each marker type
+
+Implementation: String-based pattern detection with case-insensitive matching
+"""
+
+
+def has_ignore_directive_marker(line: str) -> bool:
+    """Check if line contains a file-level ignore directive marker.
+
+    Args:
+        line: Line of code to check
+
+    Returns:
+        True if line has ignore-file marker
+    """
+    line_lower = line.lower()
+    return "# thailint: ignore-file" in line_lower or "# design-lint: ignore-file" in line_lower
+
+
+def has_line_ignore_marker(code: str) -> bool:
+    """Check if code line has an inline ignore marker.
+
+    Args:
+        code: Line of code to check
+
+    Returns:
+        True if line has inline ignore marker
+    """
+    code_lower = code.lower()
+    return (
+        "# thailint: ignore" in code_lower
+        or "# design-lint: ignore" in code_lower
+        or "// thailint: ignore" in code_lower
+        or "// design-lint: ignore" in code_lower
+    )
+
+
+def has_ignore_next_line_marker(line: str) -> bool:
+    """Check if line has ignore-next-line marker.
+
+    Args:
+        line: Line of code to check
+
+    Returns:
+        True if line has ignore-next-line marker
+    """
+    return "# thailint: ignore-next-line" in line or "# design-lint: ignore-next-line" in line
+
+
+def has_ignore_start_marker(line: str) -> bool:
+    """Check if line has ignore-start comment marker.
+
+    Only matches actual comment lines (starting with # or //), not strings
+    containing the marker text.
+
+    Args:
+        line: Line of code to check
+
+    Returns:
+        True if line is a proper ignore-start comment
+    """
+    stripped = line.strip().lower()
+    if not (stripped.startswith("#") or stripped.startswith("//")):
+        return False
+    return "ignore-start" in stripped and ("thailint:" in stripped or "design-lint:" in stripped)
+
+
+def has_ignore_end_marker(line: str) -> bool:
+    """Check if line has ignore-end comment marker.
+
+    Only matches actual comment lines (starting with # or //), not strings
+    containing the marker text.
+
+    Args:
+        line: Line of code to check
+
+    Returns:
+        True if line is a proper ignore-end comment
+    """
+    stripped = line.strip().lower()
+    if not (stripped.startswith("#") or stripped.startswith("//")):
+        return False
+    return "ignore-end" in stripped and ("thailint:" in stripped or "design-lint:" in stripped)
+
+
+def check_general_ignore(line: str) -> bool:
+    """Check if line has general ignore directive (no specific rules).
+
+    Args:
+        line: Line containing ignore directive
+
+    Returns:
+        True if no specific rules are specified (not bracket syntax)
+    """
+    return "ignore-file[" not in line