thailint 0.15.0__py3-none-any.whl → 0.15.1__py3-none-any.whl

src/cli/linters/performance.py

@@ -74,17 +74,19 @@ def _setup_and_validate(params: ExecuteParams) -> "Orchestrator":
 
 
 def _run_string_concat_lint(
-    orchestrator: "Orchestrator", path_objs: list[Path], recursive: bool
+    orchestrator: "Orchestrator", path_objs: list[Path], recursive: bool, parallel: bool = False
 ) -> list[Violation]:
     """Execute string-concat-loop lint on files or directories."""
-    all_violations = execute_linting_on_paths(orchestrator, path_objs, recursive)
+    all_violations = execute_linting_on_paths(orchestrator, path_objs, recursive, parallel)
     return [v for v in all_violations if v.rule_id == "performance.string-concat-loop"]
 
 
 def _execute_string_concat_lint(params: ExecuteParams) -> NoReturn:
     """Execute string-concat-loop lint."""
     orchestrator = _setup_and_validate(params)
-    violations = _run_string_concat_lint(orchestrator, params.path_objs, params.recursive)
+    violations = _run_string_concat_lint(
+        orchestrator, params.path_objs, params.recursive, params.parallel
+    )
 
     if params.verbose:
         logger.info(f"Found {len(violations)} string-concat-loop violation(s)")
@@ -108,17 +110,19 @@ string_concat_loop = create_linter_command(
 
 
 def _run_regex_in_loop_lint(
-    orchestrator: "Orchestrator", path_objs: list[Path], recursive: bool
+    orchestrator: "Orchestrator", path_objs: list[Path], recursive: bool, parallel: bool = False
 ) -> list[Violation]:
     """Execute regex-in-loop lint on files or directories."""
-    all_violations = execute_linting_on_paths(orchestrator, path_objs, recursive)
+    all_violations = execute_linting_on_paths(orchestrator, path_objs, recursive, parallel)
     return [v for v in all_violations if v.rule_id == "performance.regex-in-loop"]
 
 
 def _execute_regex_in_loop_lint(params: ExecuteParams) -> NoReturn:
     """Execute regex-in-loop lint."""
     orchestrator = _setup_and_validate(params)
-    violations = _run_regex_in_loop_lint(orchestrator, params.path_objs, params.recursive)
+    violations = _run_regex_in_loop_lint(
+        orchestrator, params.path_objs, params.recursive, params.parallel
+    )
 
     if params.verbose:
         logger.info(f"Found {len(violations)} regex-in-loop violation(s)")
@@ -173,7 +177,11 @@ def _filter_by_rule(violations: list[Violation], rule: str | None) -> list[Viola
 
 
 def _run_all_perf_lint(
-    orchestrator: "Orchestrator", path_objs: list[Path], recursive: bool, rule: str | None
+    orchestrator: "Orchestrator",
+    path_objs: list[Path],
+    recursive: bool,
+    rule: str | None,
+    parallel: bool = False,
 ) -> list[Violation]:
     """Execute all performance lints on files or directories.
 
@@ -182,11 +190,12 @@ def _run_all_perf_lint(
         path_objs: List of paths to analyze
         recursive: Whether to scan directories recursively
         rule: Optional rule filter (string-concat, regex-loop, or full rule names)
+        parallel: Whether to use parallel processing
 
     Returns:
         List of performance-related violations
     """
-    all_violations = execute_linting_on_paths(orchestrator, path_objs, recursive)
+    all_violations = execute_linting_on_paths(orchestrator, path_objs, recursive, parallel)
     perf_violations = [v for v in all_violations if v.rule_id.startswith("performance.")]
     return _filter_by_rule(perf_violations, rule)
 
@@ -194,7 +203,9 @@ def _run_all_perf_lint(
 def _execute_perf_lint(params: ExecuteParams, rule: str | None) -> NoReturn:
     """Execute combined performance lint."""
     orchestrator = _setup_and_validate(params)
-    violations = _run_all_perf_lint(orchestrator, params.path_objs, params.recursive, rule)
+    violations = _run_all_perf_lint(
+        orchestrator, params.path_objs, params.recursive, rule, params.parallel
+    )
 
     if params.verbose:
         logger.info(f"Found {len(violations)} performance violation(s)")
@@ -254,6 +265,7 @@ def perf(  # pylint: disable=too-many-arguments,too-many-positional-arguments
     config_file: str | None,
     format: str,
     recursive: bool,
+    parallel: bool,
     rule: str | None,
 ) -> None:
     """Run all performance linters.
@@ -264,9 +276,10 @@ def perf(  # pylint: disable=too-many-arguments,too-many-positional-arguments
         config_file: Optional path to config file
         format: Output format (text, json, sarif)
         recursive: Whether to scan directories recursively
+        parallel: Whether to use parallel processing
         rule: Optional rule filter (string-concat or regex-loop)
     """
-    params = prepare_standard_command(ctx, paths, config_file, format, recursive)
+    params = prepare_standard_command(ctx, paths, config_file, format, recursive, parallel)
 
     def execute_with_rule(p: ExecuteParams) -> None:
         _execute_perf_lint(p, rule)

src/cli/linters/shared.py

@@ -21,6 +21,10 @@ Interfaces: Orchestrator config dict manipulation, violation list filtering, CLI
     help text generation
 
 Implementation: Pure helper functions with no side effects beyond config mutation and logging
+
+Suppressions:
+    - too-many-arguments,too-many-positional-arguments: CLI helper functions require many parameters
+        by Click framework design (ctx, paths, config_file, format, recursive, parallel = 6 params)
 """
 
 import logging
@@ -30,7 +34,12 @@ from typing import TYPE_CHECKING, Any
 
 import click
 
-from src.cli.utils import format_option, get_project_root_from_context, handle_linting_error
+from src.cli.utils import (
+    format_option,
+    get_project_root_from_context,
+    handle_linting_error,
+    parallel_option,
+)
 from src.core.types import Violation
 
 if TYPE_CHECKING:
@@ -47,15 +56,17 @@ def standard_linter_options(f: Any) -> Any:
     - config file option
     - format option
     - recursive option
+    - parallel option
     - pass_context
 
     Usage:
         @cli.command("my-linter")
         @standard_linter_options
-        def my_linter(ctx, paths, config_file, format, recursive):
+        def my_linter(ctx, paths, config_file, format, recursive, parallel):
             ...
     """
     f = click.pass_context(f)
+    f = parallel_option(f)
     f = click.option(
         "--recursive/--no-recursive", default=True, help="Scan directories recursively"
     )(f)
@@ -93,6 +104,7 @@ class ExecuteParams:
     recursive: bool
     verbose: bool
     project_root: Path | None
+    parallel: bool = False
 
 
 def extract_command_context(ctx: click.Context, paths: tuple[str, ...]) -> CommandContext:
@@ -119,17 +131,18 @@ def extract_command_context(ctx: click.Context, paths: tuple[str, ...]) -> Comma
     return CommandContext(verbose=verbose, project_root=project_root, path_objs=path_objs)
 
 
-def prepare_standard_command(
+def prepare_standard_command(  # pylint: disable=too-many-arguments,too-many-positional-arguments
     ctx: click.Context,
     paths: tuple[str, ...],
     config_file: str | None,
     format: str,
     recursive: bool,
+    parallel: bool = False,
 ) -> ExecuteParams:
     """Prepare standard linter command execution parameters.
 
     Combines context extraction and ExecuteParams creation into a single call.
-    Use with commands that have the standard options (config, format, recursive).
+    Use with commands that have the standard options (config, format, recursive, parallel).
 
     Args:
         ctx: Click context from command invocation
@@ -137,6 +150,7 @@ def prepare_standard_command(
         config_file: Optional config file path
         format: Output format
         recursive: Whether to scan recursively
+        parallel: Whether to use parallel processing
 
     Returns:
         ExecuteParams ready for _execute_*_lint function
@@ -149,6 +163,7 @@ def prepare_standard_command(
         recursive=recursive,
         verbose=cmd_ctx.verbose,
         project_root=cmd_ctx.project_root,
+        parallel=parallel,
     )
 
 
@@ -258,14 +273,15 @@ def create_linter_command(
 
     @cli.command(name, help=make_linter_help(name, brief, description))
     @standard_linter_options
-    def command(
+    def command(  # pylint: disable=too-many-arguments,too-many-positional-arguments
         ctx: click.Context,
         paths: tuple[str, ...],
         config_file: str | None,
         format: str,
         recursive: bool,
+        parallel: bool,
     ) -> None:
-        params = prepare_standard_command(ctx, paths, config_file, format, recursive)
+        params = prepare_standard_command(ctx, paths, config_file, format, recursive, parallel)
         run_linter_command(execute_fn, params)
 
     return command

src/cli/linters/structure.py

@@ -44,6 +44,7 @@ from src.cli.utils import (
     get_or_detect_project_root,
     handle_linting_error,
     load_config_file,
+    parallel_option,
     setup_base_orchestrator,
     validate_paths_exist,
 )
@@ -112,6 +113,7 @@ def _parse_json_rules(rules: str) -> dict[str, Any]:
 @click.option("--rules", "-r", help="Inline JSON rules configuration")
 @format_option
 @click.option("--recursive/--no-recursive", default=True, help="Scan directories recursively")
+@parallel_option
 @click.pass_context
 def file_placement(  # pylint: disable=too-many-arguments,too-many-positional-arguments
     ctx: click.Context,
@@ -120,6 +122,7 @@ def file_placement(  # pylint: disable=too-many-arguments,too-many-positional-ar
     rules: str | None,
     format: str,
     recursive: bool,
+    parallel: bool,
 ) -> None:
     # Justification for Pylint disables:
     # - too-many-arguments/positional: CLI requires 1 ctx + 1 arg + 4 options = 6 params
@@ -166,6 +169,7 @@ def file_placement(  # pylint: disable=too-many-arguments,too-many-positional-ar
             rules,
             format,
             recursive,
+            parallel,
             cmd_ctx.verbose,
             cmd_ctx.project_root,
         )
@@ -179,13 +183,14 @@ def _execute_file_placement_lint(  # pylint: disable=too-many-arguments,too-many
     rules: str | None,
     format: str,
     recursive: bool,
+    parallel: bool,
     verbose: bool,
     project_root: Path | None = None,
 ) -> NoReturn:
     """Execute file placement linting."""
     validate_paths_exist(path_objs)
     orchestrator = _setup_orchestrator(path_objs, config_file, rules, verbose, project_root)
-    all_violations = execute_linting_on_paths(orchestrator, path_objs, recursive)
+    all_violations = execute_linting_on_paths(orchestrator, path_objs, recursive, parallel)
 
     # Filter to only file-placement violations
     violations = [v for v in all_violations if v.rule_id.startswith("file-placement")]
@@ -221,10 +226,10 @@ def _apply_pipeline_config_override(
 
 
 def _run_pipeline_lint(
-    orchestrator: "Orchestrator", path_objs: list[Path], recursive: bool
+    orchestrator: "Orchestrator", path_objs: list[Path], recursive: bool, parallel: bool = False
 ) -> list[Violation]:
     """Execute collection-pipeline lint on files or directories."""
-    all_violations = execute_linting_on_paths(orchestrator, path_objs, recursive)
+    all_violations = execute_linting_on_paths(orchestrator, path_objs, recursive, parallel)
     return [v for v in all_violations if "collection-pipeline" in v.rule_id]
 
 
@@ -234,6 +239,7 @@ def _run_pipeline_lint(
 @format_option
 @click.option("--min-continues", type=int, help="Override min continue guards to flag (default: 1)")
 @click.option("--recursive/--no-recursive", default=True, help="Scan directories recursively")
+@parallel_option
 @click.pass_context
 def pipeline(  # pylint: disable=too-many-arguments,too-many-positional-arguments
     ctx: click.Context,
@@ -242,6 +248,7 @@ def pipeline(  # pylint: disable=too-many-arguments,too-many-positional-argument
     format: str,
     min_continues: int | None,
     recursive: bool,
+    parallel: bool,
 ) -> None:
     """Check for collection pipeline anti-patterns in code.
 
@@ -289,6 +296,7 @@ def pipeline(  # pylint: disable=too-many-arguments,too-many-positional-argument
             format,
             min_continues,
             recursive,
+            parallel,
             cmd_ctx.verbose,
             cmd_ctx.project_root,
         )
@@ -302,6 +310,7 @@ def _execute_pipeline_lint(  # pylint: disable=too-many-arguments,too-many-posit
     format: str,
     min_continues: int | None,
     recursive: bool,
+    parallel: bool,
     verbose: bool,
     project_root: Path | None = None,
 ) -> NoReturn:
@@ -309,7 +318,7 @@ def _execute_pipeline_lint(  # pylint: disable=too-many-arguments,too-many-posit
     validate_paths_exist(path_objs)
     orchestrator = _setup_pipeline_orchestrator(path_objs, config_file, verbose, project_root)
     _apply_pipeline_config_override(orchestrator, min_continues, verbose)
-    pipeline_violations = _run_pipeline_lint(orchestrator, path_objs, recursive)
+    pipeline_violations = _run_pipeline_lint(orchestrator, path_objs, recursive, parallel)
 
     if verbose:
         logger.info(f"Found {len(pipeline_violations)} collection-pipeline violation(s)")

src/cli/linters/structure_quality.py

@@ -26,6 +26,7 @@ Suppressions:
 
 import logging
 import sys
+from contextlib import suppress
 from pathlib import Path
 from typing import TYPE_CHECKING, NoReturn
 
@@ -85,7 +86,7 @@ def _apply_nesting_config_override(
 def _apply_nesting_to_languages(nesting_config: dict, max_depth: int) -> None:
     """Apply max_depth to language-specific configs."""
     for lang in ["python", "typescript", "javascript"]:
-        if lang in nesting_config:
+        with suppress(KeyError):
             nesting_config[lang]["max_nesting_depth"] = max_depth
 
 
@@ -220,10 +221,10 @@ def _apply_srp_config_override(
 
 
 def _run_srp_lint(
-    orchestrator: "Orchestrator", path_objs: list[Path], recursive: bool
+    orchestrator: "Orchestrator", path_objs: list[Path], recursive: bool, parallel: bool = False
 ) -> list[Violation]:
     """Execute SRP lint on files or directories."""
-    all_violations = execute_linting_on_paths(orchestrator, path_objs, recursive)
+    all_violations = execute_linting_on_paths(orchestrator, path_objs, recursive, parallel)
     return [v for v in all_violations if "srp" in v.rule_id]
 
 
@@ -234,6 +235,7 @@ def _run_srp_lint(
 @click.option("--max-methods", type=int, help="Override max methods per class (default: 7)")
 @click.option("--max-loc", type=int, help="Override max lines of code per class (default: 200)")
 @click.option("--recursive/--no-recursive", default=True, help="Scan directories recursively")
+@parallel_option
 @click.pass_context
 def srp(  # pylint: disable=too-many-arguments,too-many-positional-arguments
     ctx: click.Context,
@@ -243,6 +245,7 @@ def srp(  # pylint: disable=too-many-arguments,too-many-positional-arguments
     max_methods: int | None,
     max_loc: int | None,
     recursive: bool,
+    parallel: bool,
 ) -> None:
     """Check for Single Responsibility Principle violations.
 
@@ -293,6 +296,7 @@ def srp(  # pylint: disable=too-many-arguments,too-many-positional-arguments
             max_methods,
             max_loc,
             recursive,
+            parallel,
             cmd_ctx.verbose,
             cmd_ctx.project_root,
         )
@@ -307,6 +311,7 @@ def _execute_srp_lint(  # pylint: disable=too-many-arguments,too-many-positional
     max_methods: int | None,
     max_loc: int | None,
     recursive: bool,
+    parallel: bool,
     verbose: bool,
     project_root: Path | None = None,
 ) -> NoReturn:
@@ -314,7 +319,7 @@ def _execute_srp_lint(  # pylint: disable=too-many-arguments,too-many-positional
     validate_paths_exist(path_objs)
     orchestrator = _setup_srp_orchestrator(path_objs, config_file, verbose, project_root)
     _apply_srp_config_override(orchestrator, max_methods, max_loc, verbose)
-    srp_violations = _run_srp_lint(orchestrator, path_objs, recursive)
+    srp_violations = _run_srp_lint(orchestrator, path_objs, recursive, parallel)
 
     if verbose:
         logger.info(f"Found {len(srp_violations)} SRP violation(s)")

src/cli/utils.py

@@ -24,8 +24,9 @@ Implementation: Uses Click decorators for option definitions, deferred imports f
 import logging
 import sys
 from collections.abc import Callable
+from contextlib import suppress
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, TypeVar
+from typing import TYPE_CHECKING, Any, TypeVar, cast
 
 import click
 
@@ -188,9 +189,8 @@ def get_project_root_from_context(ctx: click.Context) -> Path | None:
         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: Path | None = ctx.obj["project_root"]
-        return cached
+    with suppress(KeyError):
+        return cast(Path | None, ctx.obj["project_root"])
 
     project_root = _determine_project_root_for_context(ctx)
     ctx.obj["project_root"] = project_root

src/config.py

@@ -237,37 +237,47 @@ def _validate_required_keys(config: dict[str, Any], errors: list[str]) -> None:
 def _validate_log_level(config: dict[str, Any], errors: list[str]) -> None:
     """Validate log level is a valid value."""
     valid_log_levels = ["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"]
-    if "log_level" in config:
-        if config["log_level"] not in valid_log_levels:
-            errors.append(
-                f"Invalid log_level: {config['log_level']}. "
-                f"Must be one of: {', '.join(valid_log_levels)}"
-            )
+    try:
+        log_level = config["log_level"]
+    except KeyError:
+        return  # Optional key not present
+    if log_level not in valid_log_levels:
+        errors.append(
+            f"Invalid log_level: {log_level}. Must be one of: {', '.join(valid_log_levels)}"
+        )
 
 
 def _validate_output_format(config: dict[str, Any], errors: list[str]) -> None:
     """Validate output format is a valid value."""
     valid_formats = ["text", "json", "yaml"]
-    if "output_format" in config:
-        if config["output_format"] not in valid_formats:
-            errors.append(
-                f"Invalid output_format: {config['output_format']}. "
-                f"Must be one of: {', '.join(valid_formats)}"
-            )
+    try:
+        output_format = config["output_format"]
+    except KeyError:
+        return  # Optional key not present
+    if output_format not in valid_formats:
+        errors.append(
+            f"Invalid output_format: {output_format}. Must be one of: {', '.join(valid_formats)}"
+        )
 
 
 def _validate_max_retries(config: dict[str, Any], errors: list[str]) -> None:
     """Validate max_retries configuration value."""
-    if "max_retries" in config:
-        if not isinstance(config["max_retries"], int) or config["max_retries"] < 0:
-            errors.append("max_retries must be a non-negative integer")
+    try:
+        max_retries = config["max_retries"]
+    except KeyError:
+        return  # Optional key not present
+    if not isinstance(max_retries, int) or max_retries < 0:
+        errors.append("max_retries must be a non-negative integer")
 
 
 def _validate_timeout(config: dict[str, Any], errors: list[str]) -> None:
     """Validate timeout configuration value."""
-    if "timeout" in config:
-        if not isinstance(config["timeout"], (int, float)) or config["timeout"] <= 0:
-            errors.append("timeout must be a positive number")
+    try:
+        timeout = config["timeout"]
+    except KeyError:
+        return  # Optional key not present
+    if not isinstance(timeout, (int, float)) or timeout <= 0:
+        errors.append("timeout must be a positive number")
 
 
 def _validate_numeric_values(config: dict[str, Any], errors: list[str]) -> None:
@@ -278,9 +288,12 @@ def _validate_numeric_values(config: dict[str, Any], errors: list[str]) -> None:
 
 def _validate_string_values(config: dict[str, Any], errors: list[str]) -> None:
     """Validate string configuration values."""
-    if "app_name" in config:
-        if not isinstance(config["app_name"], str) or not config["app_name"].strip():
-            errors.append("app_name must be a non-empty string")
+    try:
+        app_name = config["app_name"]
+    except KeyError:
+        return  # Optional key not present
+    if not isinstance(app_name, str) or not app_name.strip():
+        errors.append("app_name must be a non-empty string")
 
 
 def validate_config(config: dict[str, Any]) -> tuple[bool, list[str]]:

src/core/python_lint_rule.py

@@ -0,0 +1,101 @@
+"""
+Purpose: Base class for Python-only linters with common boilerplate
+
+Scope: Shared infrastructure for Python-only lint rules
+
+Overview: Provides PythonOnlyLintRule abstract base class that handles common boilerplate
+    for Python-only linters. Subclasses implement the abstract properties and analysis
+    method while the base class handles language checking, config loading, and enabled
+    checking. This eliminates duplicate code across Python-only linters like CQS and LBYL.
+
+Dependencies: BaseLintRule, BaseLintContext, Language, load_linter_config, has_file_content
+
+Exports: PythonOnlyLintRule
+
+Interfaces: Subclasses implement _config_key, _config_class, _analyze, and rule metadata
+
+Implementation: Template method pattern for Python linter boilerplate
+"""
+
+from abc import abstractmethod
+from typing import Any, Generic
+
+from .base import BaseLintContext, BaseLintRule
+from .constants import Language
+from .linter_utils import ConfigType, has_file_content, load_linter_config
+from .types import Violation
+
+
+class PythonOnlyLintRule(BaseLintRule, Generic[ConfigType]):
+    """Base class for Python-only linters with common boilerplate.
+
+    Handles language checking, config loading, and enabled checking.
+    Subclasses provide the config key, config class, and analysis logic.
+    """
+
+    def __init__(self, config: ConfigType | None = None) -> None:
+        """Initialize with optional config override.
+
+        Args:
+            config: Optional configuration override for testing
+        """
+        self._config_override = config
+
+    @property
+    @abstractmethod
+    def _config_key(self) -> str:
+        """Configuration key in metadata (e.g., 'cqs', 'lbyl')."""
+        raise NotImplementedError
+
+    @property
+    @abstractmethod
+    def _config_class(self) -> type[ConfigType]:
+        """Configuration class type."""
+        raise NotImplementedError
+
+    @abstractmethod
+    def _analyze(self, code: str, file_path: str, config: ConfigType) -> list[Violation]:
+        """Perform linter-specific analysis.
+
+        Args:
+            code: Python source code
+            file_path: Path to the file
+            config: Loaded configuration
+
+        Returns:
+            List of violations found
+        """
+        raise NotImplementedError
+
+    def check(self, context: BaseLintContext) -> list[Violation]:
+        """Check for violations in the given context.
+
+        Args:
+            context: The lint context containing file information.
+
+        Returns:
+            List of violations found.
+        """
+        if not self._should_analyze(context):
+            return []
+
+        config = self._get_config(context)
+        if not self._is_enabled(config):
+            return []
+
+        file_path = str(context.file_path) if context.file_path else "unknown"
+        return self._analyze(context.file_content or "", file_path, config)
+
+    def _should_analyze(self, context: BaseLintContext) -> bool:
+        """Check if context should be analyzed."""
+        return context.language == Language.PYTHON and has_file_content(context)
+
+    def _get_config(self, context: BaseLintContext) -> ConfigType:
+        """Get configuration, using override if provided."""
+        if self._config_override is not None:
+            return self._config_override
+        return load_linter_config(context, self._config_key, self._config_class)
+
+    def _is_enabled(self, config: Any) -> bool:
+        """Check if linter is enabled in config."""
+        return getattr(config, "enabled", True)

src/linter_config/ignore.py

@@ -27,6 +27,7 @@ Suppressions:
 
 import logging
 import re
+from contextlib import suppress
 from pathlib import Path
 from typing import TYPE_CHECKING
 
@@ -66,7 +67,7 @@ class IgnoreDirectiveParser:
     def is_ignored(self, file_path: Path) -> bool:
         """Check if file matches repository-level ignore patterns (cached)."""
         path_str = str(file_path)
-        if path_str in self._ignore_cache:
+        with suppress(KeyError):
             return self._ignore_cache[path_str]
         try:
             check_path = str(file_path.relative_to(self.project_root))

src/linters/cqs/__init__.py

@@ -0,0 +1,54 @@
+"""
+Purpose: CQS (Command-Query Separation) linter package exports
+
+Scope: Detect CQS violations in Python and TypeScript code
+
+Overview: Package providing CQS violation detection for Python and TypeScript code.
+    Identifies functions that mix INPUT operations (queries that return values captured
+    in variables) and OUTPUT operations (commands that perform side effects without
+    capturing return values). Functions should either query state and return a value,
+    or command a change and return nothing. Mixing these violates CQS principles and
+    makes code harder to reason about.
+
+Dependencies: ast module for Python parsing, tree-sitter for TypeScript parsing
+
+Exports: CQSConfig, CQSPattern, CQSRule, FunctionAnalyzer, InputOperation, OutputOperation,
+    PythonCQSAnalyzer, TypeScriptCQSAnalyzer, TypeScriptFunctionAnalyzer,
+    TypeScriptInputDetector, TypeScriptOutputDetector, build_cqs_violation
+
+Interfaces: CQSConfig.from_dict() for YAML configuration loading,
+    CQSRule.check() for BaseLintRule interface
+
+Implementation: AST-based pattern detection for Python, tree-sitter for TypeScript,
+    with configurable ignore rules
+"""
+
+from .config import CQSConfig
+from .function_analyzer import FunctionAnalyzer
+from .input_detector import InputDetector
+from .linter import CQSRule
+from .output_detector import OutputDetector
+from .python_analyzer import PythonCQSAnalyzer
+from .types import CQSPattern, InputOperation, OutputOperation
+from .typescript_cqs_analyzer import TypeScriptCQSAnalyzer
+from .typescript_function_analyzer import TypeScriptFunctionAnalyzer
+from .typescript_input_detector import TypeScriptInputDetector
+from .typescript_output_detector import TypeScriptOutputDetector
+from .violation_builder import build_cqs_violation
+
+__all__ = [
+    "CQSConfig",
+    "CQSPattern",
+    "CQSRule",
+    "FunctionAnalyzer",
+    "InputDetector",
+    "InputOperation",
+    "OutputDetector",
+    "OutputOperation",
+    "PythonCQSAnalyzer",
+    "TypeScriptCQSAnalyzer",
+    "TypeScriptFunctionAnalyzer",
+    "TypeScriptInputDetector",
+    "TypeScriptOutputDetector",
+    "build_cqs_violation",
+]