thailint 0.9.0__tar.gz → 0.10.0__tar.gz

{thailint-0.9.0 → thailint-0.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: thailint
-Version: 0.9.0
+Version: 0.10.0
 Summary: The AI Linter - Enterprise-grade linting and governance for AI-generated code across multiple languages
 License: MIT
 License-File: LICENSE
@@ -37,8 +37,8 @@ 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-728%2F728%20passing-brightgreen.svg)](tests/)
-[![Coverage](https://img.shields.io/badge/coverage-87%25-brightgreen.svg)](htmlcov/)
+[![Tests](https://img.shields.io/badge/tests-795%2F795%20passing-brightgreen.svg)](tests/)
+[![Coverage](https://img.shields.io/badge/coverage-88%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)
+- **Collection Pipeline Linting** - Detect for loops with embedded filtering
+  - Based on Martin Fowler's "Replace Loop with Pipeline" refactoring
+  - Detects if/continue patterns that should use generator expressions
+  - Generates refactoring suggestions with generator syntax
+  - Configurable threshold (min_continues)
+  - Python support with AST analysis
 - **Method Property Linting** - Detect methods that should be @property decorators
   - Python AST-based detection
   - get_* prefix detection (Java-style getters)
@@ -741,6 +747,109 @@ Built-in filters automatically exclude common non-duplication patterns:
 
 See [DRY Linter Guide](https://thai-lint.readthedocs.io/en/latest/dry-linter/) for comprehensive documentation, storage modes, and refactoring patterns.
 
+## Collection Pipeline Linter
+
+### Overview
+
+The collection-pipeline linter detects for loops with embedded filtering (if/continue patterns) that should be refactored to use generator expressions or other collection pipelines. Based on Martin Fowler's "Replace Loop with Pipeline" refactoring pattern.
+
+### The Anti-Pattern
+
+```python
+# Anti-pattern: Embedded filtering in loop body
+for file_path in dir_path.glob(pattern):
+    if not file_path.is_file():
+        continue
+    if ignore_parser.is_ignored(file_path):
+        continue
+    violations.extend(lint_file(file_path))
+```
+
+### The Solution
+
+```python
+# Collection pipeline: Filtering separated from processing
+valid_files = (
+    f for f in dir_path.glob(pattern)
+    if f.is_file() and not ignore_parser.is_ignored(f)
+)
+for file_path in valid_files:
+    violations.extend(lint_file(file_path))
+```
+
+### Quick Start
+
+```bash
+# Check current directory
+thailint pipeline .
+
+# Check specific directory
+thailint pipeline src/
+
+# Only flag patterns with 2+ filter conditions
+thailint pipeline --min-continues 2 src/
+
+# JSON output
+thailint pipeline --format json src/
+```
+
+### Configuration
+
+```yaml
+# .thailint.yaml
+collection-pipeline:
+  enabled: true
+  min_continues: 1  # Minimum if/continue patterns to flag
+  ignore:
+    - "tests/**"
+    - "**/legacy/**"
+```
+
+### Example Violation
+
+**Detected Pattern:**
+```python
+def process_files(paths):
+    for path in paths:
+        if not path.is_file():
+            continue
+        analyze(path)
+```
+
+**Violation Message:**
+```
+src/processor.py:3 - For loop over 'paths' has embedded filtering.
+  Consider using a generator expression:
+  for path in (path for path in paths if path.is_file()):
+```
+
+**Refactored Code:**
+```python
+def process_files(paths):
+    valid_paths = (p for p in paths if p.is_file())
+    for path in valid_paths:
+        analyze(path)
+```
+
+### Why This Matters
+
+- **Separation of concerns**: Filtering logic is separate from processing logic
+- **Readability**: Intent is clear at a glance
+- **Testability**: Filtering can be tested independently
+- **Based on**: Martin Fowler's "Replace Loop with Pipeline" refactoring
+
+### Ignoring Violations
+
+```python
+# Line-level ignore
+for item in items:  # thailint: ignore[collection-pipeline]
+    if not item.valid:
+        continue
+    process(item)
+```
+
+See [Collection Pipeline Linter Guide](docs/collection-pipeline-linter.md) for comprehensive documentation and refactoring patterns.
+
 ## Magic Numbers Linter
 
 ### Overview
@@ -1351,6 +1460,9 @@ docker run --rm -v $(pwd):/data washad/thailint:latest nesting /data/src/file1.p
 # Lint specific subdirectory
 docker run --rm -v $(pwd):/data washad/thailint:latest nesting /data/src
 
+# Collection pipeline linter
+docker run --rm -v $(pwd):/data washad/thailint:latest pipeline /data/src
+
 # With custom config
 docker run --rm -v $(pwd):/data \
     washad/thailint:latest nesting --config /data/.thailint.yaml /data
@@ -1414,6 +1526,7 @@ docker run --rm -v /path/to/workspace:/workspace \
 - **[Nesting Depth Linter](https://thai-lint.readthedocs.io/en/latest/nesting-linter/)** - Nesting depth analysis guide
 - **[SRP Linter](https://thai-lint.readthedocs.io/en/latest/srp-linter/)** - Single Responsibility Principle guide
 - **[DRY Linter](https://thai-lint.readthedocs.io/en/latest/dry-linter/)** - Duplicate code detection guide
+- **[Collection Pipeline Linter](https://thai-lint.readthedocs.io/en/latest/collection-pipeline-linter/)** - Loop filtering refactoring guide
 - **[Method Property Linter](https://thai-lint.readthedocs.io/en/latest/method-property-linter/)** - Method-to-property conversion guide
 - **[Stateless Class Linter](https://thai-lint.readthedocs.io/en/latest/stateless-class-linter/)** - Stateless class detection guide
 - **[Pre-commit Hooks](https://thai-lint.readthedocs.io/en/latest/pre-commit-hooks/)** - Automated quality checks

{thailint-0.9.0 → thailint-0.10.0}/README.md

@@ -2,8 +2,8 @@
 
 [![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-728%2F728%20passing-brightgreen.svg)](tests/)
-[![Coverage](https://img.shields.io/badge/coverage-87%25-brightgreen.svg)](htmlcov/)
+[![Tests](https://img.shields.io/badge/tests-795%2F795%20passing-brightgreen.svg)](tests/)
+[![Coverage](https://img.shields.io/badge/coverage-88%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)
+- **Collection Pipeline Linting** - Detect for loops with embedded filtering
+  - Based on Martin Fowler's "Replace Loop with Pipeline" refactoring
+  - Detects if/continue patterns that should use generator expressions
+  - Generates refactoring suggestions with generator syntax
+  - Configurable threshold (min_continues)
+  - Python support with AST analysis
 - **Method Property Linting** - Detect methods that should be @property decorators
   - Python AST-based detection
   - get_* prefix detection (Java-style getters)
@@ -706,6 +712,109 @@ Built-in filters automatically exclude common non-duplication patterns:
 
 See [DRY Linter Guide](https://thai-lint.readthedocs.io/en/latest/dry-linter/) for comprehensive documentation, storage modes, and refactoring patterns.
 
+## Collection Pipeline Linter
+
+### Overview
+
+The collection-pipeline linter detects for loops with embedded filtering (if/continue patterns) that should be refactored to use generator expressions or other collection pipelines. Based on Martin Fowler's "Replace Loop with Pipeline" refactoring pattern.
+
+### The Anti-Pattern
+
+```python
+# Anti-pattern: Embedded filtering in loop body
+for file_path in dir_path.glob(pattern):
+    if not file_path.is_file():
+        continue
+    if ignore_parser.is_ignored(file_path):
+        continue
+    violations.extend(lint_file(file_path))
+```
+
+### The Solution
+
+```python
+# Collection pipeline: Filtering separated from processing
+valid_files = (
+    f for f in dir_path.glob(pattern)
+    if f.is_file() and not ignore_parser.is_ignored(f)
+)
+for file_path in valid_files:
+    violations.extend(lint_file(file_path))
+```
+
+### Quick Start
+
+```bash
+# Check current directory
+thailint pipeline .
+
+# Check specific directory
+thailint pipeline src/
+
+# Only flag patterns with 2+ filter conditions
+thailint pipeline --min-continues 2 src/
+
+# JSON output
+thailint pipeline --format json src/
+```
+
+### Configuration
+
+```yaml
+# .thailint.yaml
+collection-pipeline:
+  enabled: true
+  min_continues: 1  # Minimum if/continue patterns to flag
+  ignore:
+    - "tests/**"
+    - "**/legacy/**"
+```
+
+### Example Violation
+
+**Detected Pattern:**
+```python
+def process_files(paths):
+    for path in paths:
+        if not path.is_file():
+            continue
+        analyze(path)
+```
+
+**Violation Message:**
+```
+src/processor.py:3 - For loop over 'paths' has embedded filtering.
+  Consider using a generator expression:
+  for path in (path for path in paths if path.is_file()):
+```
+
+**Refactored Code:**
+```python
+def process_files(paths):
+    valid_paths = (p for p in paths if p.is_file())
+    for path in valid_paths:
+        analyze(path)
+```
+
+### Why This Matters
+
+- **Separation of concerns**: Filtering logic is separate from processing logic
+- **Readability**: Intent is clear at a glance
+- **Testability**: Filtering can be tested independently
+- **Based on**: Martin Fowler's "Replace Loop with Pipeline" refactoring
+
+### Ignoring Violations
+
+```python
+# Line-level ignore
+for item in items:  # thailint: ignore[collection-pipeline]
+    if not item.valid:
+        continue
+    process(item)
+```
+
+See [Collection Pipeline Linter Guide](docs/collection-pipeline-linter.md) for comprehensive documentation and refactoring patterns.
+
 ## Magic Numbers Linter
 
 ### Overview
@@ -1316,6 +1425,9 @@ docker run --rm -v $(pwd):/data washad/thailint:latest nesting /data/src/file1.p
 # Lint specific subdirectory
 docker run --rm -v $(pwd):/data washad/thailint:latest nesting /data/src
 
+# Collection pipeline linter
+docker run --rm -v $(pwd):/data washad/thailint:latest pipeline /data/src
+
 # With custom config
 docker run --rm -v $(pwd):/data \
     washad/thailint:latest nesting --config /data/.thailint.yaml /data
@@ -1379,6 +1491,7 @@ docker run --rm -v /path/to/workspace:/workspace \
 - **[Nesting Depth Linter](https://thai-lint.readthedocs.io/en/latest/nesting-linter/)** - Nesting depth analysis guide
 - **[SRP Linter](https://thai-lint.readthedocs.io/en/latest/srp-linter/)** - Single Responsibility Principle guide
 - **[DRY Linter](https://thai-lint.readthedocs.io/en/latest/dry-linter/)** - Duplicate code detection guide
+- **[Collection Pipeline Linter](https://thai-lint.readthedocs.io/en/latest/collection-pipeline-linter/)** - Loop filtering refactoring guide
 - **[Method Property Linter](https://thai-lint.readthedocs.io/en/latest/method-property-linter/)** - Method-to-property conversion guide
 - **[Stateless Class Linter](https://thai-lint.readthedocs.io/en/latest/stateless-class-linter/)** - Stateless class detection guide
 - **[Pre-commit Hooks](https://thai-lint.readthedocs.io/en/latest/pre-commit-hooks/)** - Automated quality checks

{thailint-0.9.0 → thailint-0.10.0}/pyproject.toml

@@ -17,7 +17,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "thailint"
-version = "0.9.0"
+version = "0.10.0"
 description = "The AI Linter - Enterprise-grade linting and governance for AI-generated code across multiple languages"
 authors = ["Steve Jackson"]
 license = "MIT"

{thailint-0.9.0 → thailint-0.10.0}/src/cli.py

@@ -2010,5 +2010,132 @@ def _execute_stateless_class_lint(  # pylint: disable=too-many-arguments,too-man
     sys.exit(1 if stateless_class_violations else 0)
 
 
+# Collection Pipeline command helper functions
+
+
+def _setup_pipeline_orchestrator(
+    path_objs: list[Path], config_file: str | None, verbose: bool, project_root: Path | None = None
+):
+    """Set up orchestrator for pipeline 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 _apply_pipeline_config_override(orchestrator, min_continues: int | None, verbose: bool):
+    """Apply min_continues override to orchestrator config."""
+    if min_continues is None:
+        return
+
+    if "collection_pipeline" not in orchestrator.config:
+        orchestrator.config["collection_pipeline"] = {}
+
+    orchestrator.config["collection_pipeline"]["min_continues"] = min_continues
+    if verbose:
+        logger.debug(f"Overriding min_continues to {min_continues}")
+
+
+def _run_pipeline_lint(orchestrator, path_objs: list[Path], recursive: bool):
+    """Execute collection-pipeline lint on files or directories."""
+    all_violations = _execute_linting_on_paths(orchestrator, path_objs, recursive)
+    return [v for v in all_violations if "collection-pipeline" in v.rule_id]
+
+
+@cli.command("pipeline")
+@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("--min-continues", type=int, help="Override min continue guards to flag (default: 1)")
+@click.option("--recursive/--no-recursive", default=True, help="Scan directories recursively")
+@click.pass_context
+def pipeline(  # pylint: disable=too-many-arguments,too-many-positional-arguments
+    ctx,
+    paths: tuple[str, ...],
+    config_file: str | None,
+    format: str,
+    min_continues: int | None,
+    recursive: bool,
+):
+    """Check for collection pipeline anti-patterns in code.
+
+    Detects for loops with embedded if/continue filtering patterns that could
+    be refactored to use collection pipelines (generator expressions, filter()).
+
+    PATHS: Files or directories to lint (defaults to current directory if none provided)
+
+    Examples:
+
+        \b
+        # Check current directory (all Python files recursively)
+        thai-lint pipeline
+
+        \b
+        # Check specific directory
+        thai-lint pipeline src/
+
+        \b
+        # Check single file
+        thai-lint pipeline src/app.py
+
+        \b
+        # Only flag loops with 2+ continue guards
+        thai-lint pipeline --min-continues 2 src/
+
+        \b
+        # Get JSON output
+        thai-lint pipeline --format json .
+
+        \b
+        # Get SARIF output for CI/CD integration
+        thai-lint pipeline --format sarif src/
+
+        \b
+        # Use custom config file
+        thai-lint pipeline --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_pipeline_lint(
+            path_objs, config_file, format, min_continues, recursive, verbose, project_root
+        )
+    except Exception as e:
+        _handle_linting_error(e, verbose)
+
+
+def _execute_pipeline_lint(  # pylint: disable=too-many-arguments,too-many-positional-arguments
+    path_objs, config_file, format, min_continues, recursive, verbose, project_root=None
+):
+    """Execute collection-pipeline lint."""
+    _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)
+
+    if verbose:
+        logger.info(f"Found {len(pipeline_violations)} collection-pipeline violation(s)")
+
+    format_violations(pipeline_violations, format)
+    sys.exit(1 if pipeline_violations else 0)
+
+
 if __name__ == "__main__":
     cli()

{thailint-0.9.0 → thailint-0.10.0}/src/config.py

@@ -103,9 +103,8 @@ def _load_from_explicit_path(config_path: Path) -> dict[str, Any]:
 
 def _load_from_default_locations() -> dict[str, Any]:
     """Load config from default locations."""
-    for location in CONFIG_LOCATIONS:
-        if not location.exists():
-            continue
+    existing_locations = (loc for loc in CONFIG_LOCATIONS if loc.exists())
+    for location in existing_locations:
         loaded_config = _try_load_from_location(location)
         if loaded_config:
             return loaded_config

{thailint-0.9.0 → thailint-0.10.0}/src/core/rule_discovery.py

@@ -20,6 +20,7 @@ Implementation: Package traversal with pkgutil, class introspection with inspect
 import importlib
 import inspect
 import pkgutil
+from types import ModuleType
 from typing import Any
 
 from .base import BaseLintRule
@@ -87,19 +88,51 @@ def _discover_from_module(module_path: str) -> list[BaseLintRule]:
     Returns:
         List of discovered rule instances
     """
+    module = _try_import_module(module_path)
+    if module is None:
+        return []
+    return _extract_rules_from_module(module)
+
+
+def _try_import_module(module_path: str) -> ModuleType | None:
+    """Try to import a module, returning None on failure.
+
+    Args:
+        module_path: Full module path to import
+
+    Returns:
+        Module object or None if import fails
+    """
     try:
-        module = importlib.import_module(module_path)
+        return importlib.import_module(module_path)
     except (ImportError, AttributeError):
-        return []
+        return None
 
-    rules = []
-    for _name, obj in inspect.getmembers(module):
-        if not _is_rule_class(obj):
-            continue
-        rule_instance = _try_instantiate_rule(obj)
-        if rule_instance:
-            rules.append(rule_instance)
-    return rules
+
+def _extract_rules_from_module(module: ModuleType) -> list[BaseLintRule]:
+    """Extract rule instances from a module.
+
+    Args:
+        module: Imported module to scan
+
+    Returns:
+        List of discovered rule instances
+    """
+    rule_classes = [obj for _name, obj in inspect.getmembers(module) if _is_rule_class(obj)]
+    return _instantiate_rules(rule_classes)
+
+
+def _instantiate_rules(rule_classes: list[type[BaseLintRule]]) -> list[BaseLintRule]:
+    """Instantiate a list of rule classes.
+
+    Args:
+        rule_classes: List of rule classes to instantiate
+
+    Returns:
+        List of successfully instantiated rules
+    """
+    instances = (_try_instantiate_rule(cls) for cls in rule_classes)
+    return [inst for inst in instances if inst is not None]
 
 
 def _try_instantiate_rule(rule_class: type[BaseLintRule]) -> BaseLintRule | None:

thailint-0.10.0/src/linters/collection_pipeline/__init__.py

@@ -0,0 +1,90 @@
+"""
+Purpose: Collection pipeline linter package initialization
+
+Scope: Exports for collection-pipeline linter module
+
+Overview: Initializes the collection-pipeline linter package and exposes the main rule class
+    for external use. Exports CollectionPipelineRule as the primary interface for the linter,
+    allowing the orchestrator to discover and instantiate the rule. Also exports configuration
+    and detector classes for advanced use cases. Provides a convenience lint() function for
+    direct usage without orchestrator setup. This module serves as the entry point for
+    the collection-pipeline linter functionality within the thai-lint framework.
+
+Dependencies: CollectionPipelineRule, CollectionPipelineConfig, PipelinePatternDetector
+
+Exports: CollectionPipelineRule (primary), CollectionPipelineConfig, PipelinePatternDetector, lint
+
+Interfaces: Standard Python package initialization with __all__ for explicit exports
+
+Implementation: Simple re-export pattern for package interface, convenience lint function
+"""
+
+from pathlib import Path
+from typing import Any
+
+from .config import DEFAULT_MIN_CONTINUES, CollectionPipelineConfig
+from .detector import PatternMatch, PipelinePatternDetector
+from .linter import CollectionPipelineRule
+
+__all__ = [
+    "CollectionPipelineRule",
+    "CollectionPipelineConfig",
+    "PipelinePatternDetector",
+    "PatternMatch",
+    "lint",
+]
+
+
+def lint(
+    path: Path | str,
+    config: dict[str, Any] | None = None,
+    min_continues: int = DEFAULT_MIN_CONTINUES,
+) -> list:
+    """Lint a file or directory for collection pipeline violations.
+
+    Args:
+        path: Path to file or directory to lint
+        config: Configuration dict (optional, uses defaults if not provided)
+        min_continues: Minimum if/continue patterns to flag (default: 1)
+
+    Returns:
+        List of violations found
+
+    Example:
+        >>> from src.linters.collection_pipeline import lint
+        >>> violations = lint('src/my_module.py', min_continues=2)
+        >>> for v in violations:
+        ...     print(f"{v.file_path}:{v.line} - {v.message}")
+    """
+    path_obj = Path(path) if isinstance(path, str) else path
+    project_root = path_obj if path_obj.is_dir() else path_obj.parent
+
+    orchestrator = _setup_pipeline_orchestrator(project_root, config, min_continues)
+    violations = _execute_pipeline_lint(orchestrator, path_obj)
+
+    return [v for v in violations if "collection-pipeline" in v.rule_id]
+
+
+def _setup_pipeline_orchestrator(
+    project_root: Path, config: dict[str, Any] | None, min_continues: int
+) -> Any:
+    """Set up orchestrator with collection-pipeline config."""
+    from src.orchestrator.core import Orchestrator
+
+    orchestrator = Orchestrator(project_root=project_root)
+
+    if config:
+        orchestrator.config["collection-pipeline"] = config
+    else:
+        orchestrator.config["collection-pipeline"] = {"min_continues": min_continues}
+
+    return orchestrator
+
+
+def _execute_pipeline_lint(orchestrator: Any, path_obj: Path) -> list:
+    """Execute linting on file or directory."""
+    if path_obj.is_file():
+        return orchestrator.lint_file(path_obj)
+    if path_obj.is_dir():
+        return orchestrator.lint_directory(path_obj)
+    return []

thailint-0.10.0/src/linters/collection_pipeline/config.py

@@ -0,0 +1,63 @@
+"""
+Purpose: Configuration dataclass for collection-pipeline linter
+
+Scope: Define configurable options for embedded filtering pattern detection
+
+Overview: Provides CollectionPipelineConfig for customizing linter behavior including
+    minimum number of continue patterns to flag, enable/disable toggle, and ignore
+    patterns. Integrates with the orchestrator's configuration system to allow users
+    to customize collection-pipeline detection via .thailint.yaml configuration files.
+    Follows the same configuration pattern as other thai-lint linters.
+
+Dependencies: dataclasses, typing
+
+Exports: CollectionPipelineConfig dataclass, DEFAULT_MIN_CONTINUES constant
+
+Interfaces: CollectionPipelineConfig.from_dict() class method for configuration loading
+
+Implementation: Dataclass with sensible defaults and config loading from dictionary
+"""
+
+from dataclasses import dataclass, field
+from typing import Any
+
+# Default threshold for minimum continue guards to flag
+DEFAULT_MIN_CONTINUES = 1
+
+
+@dataclass
+class CollectionPipelineConfig:
+    """Configuration for collection-pipeline linter."""
+
+    enabled: bool = True
+    """Whether the linter is enabled."""
+
+    min_continues: int = DEFAULT_MIN_CONTINUES
+    """Minimum number of if/continue patterns required to flag a violation."""
+
+    ignore: list[str] = field(default_factory=list)
+    """File patterns to ignore."""
+
+    def __post_init__(self) -> None:
+        """Validate configuration values."""
+        if self.min_continues < 1:
+            raise ValueError(f"min_continues must be at least 1, got {self.min_continues}")
+
+    @classmethod
+    def from_dict(
+        cls, config: dict[str, Any], language: str | None = None
+    ) -> "CollectionPipelineConfig":
+        """Load configuration from dictionary.
+
+        Args:
+            config: Dictionary containing configuration values
+            language: Programming language (unused, for interface compatibility)
+
+        Returns:
+            CollectionPipelineConfig instance with values from dictionary
+        """
+        return cls(
+            enabled=config.get("enabled", True),
+            min_continues=config.get("min_continues", DEFAULT_MIN_CONTINUES),
+            ignore=config.get("ignore", []),
+        )