thailint 0.1.5__py3-none-any.whl → 0.5.0__py3-none-any.whl

src/linters/file_placement/linter.py

@@ -1,57 +1,56 @@
 """
 Purpose: File placement linter implementation
+
 Scope: Validate file organization against allow/deny patterns
+
 Overview: Implements file placement validation using regex patterns from JSON/YAML config.
-    Supports directory-specific rules, global patterns, and generates helpful suggestions.
-Dependencies: src.core (base classes, types), pathlib, json, re
+    Orchestrates configuration loading, pattern validation, path resolution, rule checking,
+    and violation creation through focused helper classes. Supports directory-specific rules,
+    global patterns, and generates helpful suggestions. Main linter class acts as coordinator.
+
+Dependencies: src.core (base classes, types), pathlib, typing
+
 Exports: FilePlacementLinter, FilePlacementRule
-Implementation: Pattern matching with deny-takes-precedence logic
+
+Implementation: Composition pattern with helper classes for each responsibility
+
+SRP Exception: FilePlacementRule has 13 methods (exceeds max 8)
+    Justification: Framework adapter class that bridges BaseLintRule interface with
+    FilePlacementLinter implementation. Must handle multiple config sources (metadata vs file),
+    multiple config formats (wrapped vs unwrapped), project root detection with fallbacks,
+    and linter caching. This complexity is inherent to adapter pattern - splitting would
+    create unnecessary indirection between framework and implementation without improving
+    maintainability. All methods are focused on the single responsibility of integrating
+    file placement validation with the linting framework.
 """
 
 import json
-import re
 from pathlib import Path
 from typing import Any
 
 import yaml
 
 from src.core.base import BaseLintContext, BaseLintRule
-from src.core.types import Severity, Violation
-
+from src.core.types import Violation
 
-class PatternMatcher:
-    """Handles regex pattern matching for file paths."""
-
-    def match_deny_patterns(
-        self, path_str: str, deny_patterns: list[dict[str, str]]
-    ) -> tuple[bool, str | None]:
-        """Check if path matches any deny patterns.
-
-        Args:
-            path_str: File path to check
-            deny_patterns: List of deny pattern dicts with 'pattern' and 'reason'
-
-        Returns:
-            Tuple of (is_denied, reason)
-        """
-        for deny_item in deny_patterns:
-            pattern = deny_item["pattern"]
-            if re.search(pattern, path_str, re.IGNORECASE):
-                reason = deny_item.get("reason", "File not allowed in this location")
-                return True, reason
-        return False, None
+from .config_loader import ConfigLoader
+from .path_resolver import PathResolver
+from .pattern_matcher import PatternMatcher
+from .pattern_validator import PatternValidator
+from .rule_checker import RuleChecker
+from .violation_factory import ViolationFactory
 
-    def match_allow_patterns(self, path_str: str, allow_patterns: list[str]) -> bool:
-        """Check if path matches any allow patterns.
 
-        Args:
-            path_str: File path to check
-            allow_patterns: List of regex patterns
+class _Components:
+    """Container for linter components to reduce instance attributes."""
 
-        Returns:
-            True if path matches any pattern
-        """
-        return any(re.search(pattern, path_str, re.IGNORECASE) for pattern in allow_patterns)
+    def __init__(self, project_root: Path):
+        self.config_loader = ConfigLoader(project_root)
+        self.path_resolver = PathResolver(project_root)
+        self.pattern_matcher = PatternMatcher()
+        self.pattern_validator = PatternValidator()
+        self.violation_factory = ViolationFactory()
+        self.rule_checker = RuleChecker(self.pattern_matcher, self.violation_factory)
 
 
 class FilePlacementLinter:
@@ -71,551 +70,343 @@ class FilePlacementLinter:
             project_root: Project root directory
         """
         self.project_root = project_root or Path.cwd()
-        self.pattern_matcher = PatternMatcher()
+        self._components = _Components(self.project_root)
 
-        # Load config
+        # Load and validate config
         if config_obj:
-            self.config = config_obj
+            # Handle both wrapped and unwrapped config formats
+            # Wrapped: {"file-placement": {...}} or {"file_placement": {...}}
+            # Unwrapped: {"directories": {...}, "global_deny": [...], ...}
+            # Try both hyphenated and underscored keys for backward compatibility
+            self.config = config_obj.get(
+                "file-placement", config_obj.get("file_placement", config_obj)
+            )
         elif config_file:
-            self.config = self._load_config_file(config_file)
+            self.config = self._components.config_loader.load_config_file(config_file)
         else:
             self.config = {}
 
         # Validate regex patterns in config
-        self._validate_regex_patterns()
+        self._components.pattern_validator.validate_config(self.config)
 
-    def _validate_pattern(self, pattern: str) -> None:
-        """Validate a single regex pattern.
+    def lint_path(self, file_path: Path) -> list[Violation]:
+        """Lint a single file path.
 
         Args:
-            pattern: Regex pattern to validate
+            file_path: File to lint
 
-        Raises:
-            ValueError: If pattern is invalid
-        """
-        try:
-            re.compile(pattern)
-        except re.error as e:
-            raise ValueError(f"Invalid regex pattern '{pattern}': {e}") from e
-
-    def _validate_allow_patterns(self, rules: dict[str, Any]) -> None:
-        """Validate allow patterns in a rules dict."""
-        if "allow" in rules:
-            for pattern in rules["allow"]:
-                self._validate_pattern(pattern)
-
-    def _validate_deny_patterns(self, rules: dict[str, Any]) -> None:
-        """Validate deny patterns in a rules dict."""
-        if "deny" in rules:
-            for deny_item in rules["deny"]:
-                pattern = deny_item.get("pattern", "")
-                self._validate_pattern(pattern)
-
-    def _validate_directory_patterns(self, fp_config: dict[str, Any]) -> None:
-        """Validate all directory-specific patterns."""
-        if "directories" in fp_config:
-            for _dir_path, rules in fp_config["directories"].items():
-                self._validate_allow_patterns(rules)
-                self._validate_deny_patterns(rules)
-
-    def _validate_global_patterns(self, fp_config: dict[str, Any]) -> None:
-        """Validate global patterns section."""
-        if "global_patterns" in fp_config:
-            self._validate_allow_patterns(fp_config["global_patterns"])
-            self._validate_deny_patterns(fp_config["global_patterns"])
-
-    def _validate_global_deny_patterns(self, fp_config: dict[str, Any]) -> None:
-        """Validate global_deny patterns."""
-        if "global_deny" in fp_config:
-            for deny_item in fp_config["global_deny"]:
-                pattern = deny_item.get("pattern", "")
-                self._validate_pattern(pattern)
-
-    def _validate_regex_patterns(self) -> None:
-        """Validate all regex patterns in config.
-
-        Raises:
-            re.error: If any regex pattern is invalid
+        Returns:
+            List of violations found
         """
-        fp_config = self.config.get("file-placement", {})
-
-        self._validate_directory_patterns(fp_config)
-        self._validate_global_patterns(fp_config)
-        self._validate_global_deny_patterns(fp_config)
-
-    def _resolve_config_path(self, config_file: str) -> Path:
-        """Resolve config file path relative to project root."""
-        config_path = Path(config_file)
-        if not config_path.is_absolute():
-            config_path = self.project_root / config_path
-        return config_path
-
-    def _parse_config_file(self, config_path: Path) -> dict[str, Any]:
-        """Parse config file based on extension."""
-        with config_path.open(encoding="utf-8") as f:
-            if config_path.suffix in [".yaml", ".yml"]:
-                return yaml.safe_load(f) or {}
-            if config_path.suffix == ".json":
-                return json.load(f)
-            raise ValueError(f"Unsupported config format: {config_path.suffix}")
+        rel_path = self._components.path_resolver.get_relative_path(file_path)
+        path_str = self._components.path_resolver.normalize_path_string(rel_path)
+        # Config is already unwrapped from file-placement key in _load_layout_config
+        fp_config = self.config
+        return self._components.rule_checker.check_all_rules(path_str, rel_path, fp_config)
 
-    def _load_config_file(self, config_file: str) -> dict[str, Any]:
-        """Load configuration from file.
+    def check_file_allowed(self, file_path: Path) -> bool:
+        """Check if file is allowed (no violations).
 
         Args:
-            config_file: Path to config file
+            file_path: File to check
 
         Returns:
-            Loaded configuration dict
-
-        Raises:
-            Exception: If file cannot be loaded or parsed
+            True if file is allowed (no violations)
         """
-        config_path = self._resolve_config_path(config_file)
-        if not config_path.exists():
-            return {}
-        return self._parse_config_file(config_path)
+        violations = self.lint_path(file_path)
+        return len(violations) == 0
 
-    def _get_relative_path(self, file_path: Path) -> Path:
-        """Get path relative to project root, or return as-is."""
-        try:
-            if file_path.is_absolute():
-                return file_path.relative_to(self.project_root)
-            return file_path
-        except ValueError:
-            # If path is outside project root, return it as-is
-            # This allows detection of absolute paths in global_deny patterns
-            return file_path
-
-    def _check_all_rules(
-        self, path_str: str, rel_path: Path, fp_config: dict[str, Any]
-    ) -> list[Violation]:
-        """Check all file placement rules."""
-        violations: list[Violation] = []
-
-        if "directories" in fp_config:
-            dir_violations = self._check_directory_rules(
-                path_str, rel_path, fp_config["directories"]
-            )
-            violations.extend(dir_violations)
+    def lint_directory(self, dir_path: Path, recursive: bool = True) -> list[Violation]:
+        """Lint all files in directory.
 
-        if "global_deny" in fp_config:
-            deny_violations = self._check_global_deny(path_str, rel_path, fp_config["global_deny"])
-            violations.extend(deny_violations)
+        Args:
+            dir_path: Directory to scan
+            recursive: Scan recursively
 
-        if "global_patterns" in fp_config:
-            global_violations = self._check_global_patterns(
-                path_str, rel_path, fp_config["global_patterns"]
-            )
-            violations.extend(global_violations)
+        Returns:
+            List of all violations found
+        """
+        from src.linter_config.ignore import IgnoreDirectiveParser
+
+        ignore_parser = IgnoreDirectiveParser(self.project_root)
+        pattern = "**/*" if recursive else "*"
+
+        violations = []
+        for file_path in dir_path.glob(pattern):
+            if not file_path.is_file():
+                continue
+            if ignore_parser.is_ignored(file_path):
+                continue
+            file_violations = self.lint_path(file_path)
+            violations.extend(file_violations)
 
         return violations
 
-    def lint_path(self, file_path: Path) -> list[Violation]:
-        """Lint a single file path.
 
-        Args:
-            file_path: File to lint
+class FilePlacementRule(BaseLintRule):  # thailint: ignore[srp.violation]
+    """File placement linting rule (integrates with framework).
 
-        Returns:
-            List of violations found
+    SRP suppression: Framework adapter class requires 13 methods to bridge
+    BaseLintRule interface with FilePlacementLinter. See file header for justification.
+    """
+
+    def __init__(self, config: dict[str, Any] | None = None):
+        """Initialize rule with config.
+
+        Args:
+            config: Rule configuration
         """
-        rel_path = self._get_relative_path(file_path)
-        path_str = str(rel_path).replace("\\", "/")
-        fp_config = self.config.get("file-placement", {})
-        return self._check_all_rules(path_str, rel_path, fp_config)
-
-    def _create_deny_violation(self, rel_path: Path, matched_path: str, reason: str) -> Violation:
-        """Create violation for denied file."""
-        message = f"File '{rel_path}' not allowed in {matched_path}: {reason}"
-        suggestion = self._get_suggestion(rel_path.name, matched_path)
-        return Violation(
-            rule_id="file-placement",
-            file_path=str(rel_path),
-            line=1,
-            column=0,
-            message=message,
-            severity=Severity.ERROR,
-            suggestion=suggestion,
-        )
-
-    def _create_allow_violation(self, rel_path: Path, matched_path: str) -> Violation:
-        """Create violation for file not matching allow patterns."""
-        message = f"File '{rel_path}' does not match allowed patterns for {matched_path}"
-        suggestion = f"Move to {matched_path} or ensure file type is allowed"
-        return Violation(
-            rule_id="file-placement",
-            file_path=str(rel_path),
-            line=1,
-            column=0,
-            message=message,
-            severity=Severity.ERROR,
-            suggestion=suggestion,
-        )
-
-    def _check_deny_patterns(
-        self, path_str: str, rel_path: Path, dir_rule: dict[str, Any], matched_path: str
-    ) -> list[Violation]:
-        """Check deny patterns and return violations if denied."""
-        if "deny" not in dir_rule:
-            return []
+        self.config = config or {}
+        self._linter_cache: dict[Path, FilePlacementLinter] = {}
 
-        is_denied, reason = self.pattern_matcher.match_deny_patterns(path_str, dir_rule["deny"])
-        if is_denied:
-            return [self._create_deny_violation(rel_path, matched_path, reason or "Pattern denied")]
-        return []
+    @property
+    def rule_id(self) -> str:
+        """Return rule ID."""
+        return "file-placement"
 
-    def _check_allow_patterns(
-        self, path_str: str, rel_path: Path, dir_rule: dict[str, Any], matched_path: str
-    ) -> list[Violation]:
-        """Check allow patterns and return violations if not allowed."""
-        if "allow" not in dir_rule:
-            return []
+    @property
+    def rule_name(self) -> str:
+        """Return rule name."""
+        return "File Placement"
 
-        if not self.pattern_matcher.match_allow_patterns(path_str, dir_rule["allow"]):
-            return [self._create_allow_violation(rel_path, matched_path)]
-        return []
+    @property
+    def description(self) -> str:
+        """Return rule description."""
+        return "Validate file organization against project structure rules"
 
-    def _check_directory_rules(
-        self, path_str: str, rel_path: Path, directories: dict[str, Any]
-    ) -> list[Violation]:
-        """Check file against directory-specific rules.
+    def check(self, context: BaseLintContext) -> list[Violation]:
+        """Check file placement.
 
         Args:
-            path_str: File path string
-            rel_path: Relative path
-            directories: Directory rules config
+            context: Lint context
 
         Returns:
             List of violations
         """
-        dir_rule, matched_path = self._find_matching_directory_rule(path_str, directories)
-        if not dir_rule or not matched_path:
+        if not context.file_path:
             return []
 
-        deny_violations = self._check_deny_patterns(path_str, rel_path, dir_rule, matched_path)
-        if deny_violations:
-            return deny_violations
-
-        return self._check_allow_patterns(path_str, rel_path, dir_rule, matched_path)
-
-    def _check_root_match(self, dir_path: str, path_str: str) -> tuple[bool, int]:
-        """Check if path matches root directory rule."""
-        if dir_path == "/" and "/" not in path_str:
-            return True, 0
-        return False, -1
-
-    def _check_path_match(self, dir_path: str, path_str: str) -> tuple[bool, int]:
-        """Check if path matches directory rule."""
-        if dir_path == "/":
-            return self._check_root_match(dir_path, path_str)
-        if path_str.startswith(dir_path):
-            depth = len(dir_path.split("/"))
-            return True, depth
-        return False, -1
+        project_root = self._get_project_root(context)
+        linter = self._get_or_create_linter(project_root, context)
+        return linter.lint_path(context.file_path)
 
-    def _find_matching_directory_rule(
-        self, path_str: str, directories: dict[str, Any]
-    ) -> tuple[dict[str, Any] | None, str | None]:
-        """Find most specific directory rule matching the path.
+    def _get_project_root(self, context: BaseLintContext) -> Path:
+        """Get project root from context or detect it.
 
         Args:
-            path_str: File path string
-            directories: Directory rules
+            context: Lint context
 
         Returns:
-            Tuple of (rule_dict, matched_path)
+            Project root directory path
         """
-        best_match = None
-        best_path = None
-        best_depth = -1
-
-        for dir_path, rules in directories.items():
-            matches, depth = self._check_path_match(dir_path, path_str)
-            if matches and depth > best_depth:
-                best_match = rules
-                best_path = dir_path
-                best_depth = depth
+        # Use project root from orchestrator metadata if available
+        metadata_root = self._get_root_from_metadata(context)
+        if metadata_root is not None:
+            return metadata_root
 
-        return best_match, best_path
+        # Otherwise detect it from file path
+        return self._detect_project_root(context)
 
-    def _check_global_deny(
-        self, path_str: str, rel_path: Path, global_deny: list[dict[str, str]]
-    ) -> list[Violation]:
-        """Check file against global deny patterns.
+    def _get_root_from_metadata(self, context: BaseLintContext) -> Path | None:
+        """Extract project root from context metadata.
 
         Args:
-            path_str: File path string
-            rel_path: Relative path
-            global_deny: Global deny patterns
+            context: Lint context
 
         Returns:
-            List of violations
+            Project root from metadata, or None if not available
         """
-        violations = []
-        is_denied, reason = self.pattern_matcher.match_deny_patterns(path_str, global_deny)
-        if is_denied:
-            violations.append(
-                Violation(
-                    rule_id="file-placement",
-                    file_path=str(rel_path),
-                    line=1,
-                    column=0,
-                    message=reason or f"File '{rel_path}' matches denied pattern",
-                    severity=Severity.ERROR,
-                    suggestion=self._get_suggestion(rel_path.name, None),
-                )
-            )
-        return violations
+        if not hasattr(context, "metadata"):
+            return None
+        if not context.metadata:
+            return None
+        if "_project_root" not in context.metadata:
+            return None
+        return context.metadata["_project_root"]
 
-    def _check_global_deny_patterns(
-        self, path_str: str, rel_path: Path, global_patterns: dict[str, Any]
-    ) -> list[Violation]:
-        """Check global deny patterns."""
-        if "deny" not in global_patterns:
-            return []
-
-        is_denied, reason = self.pattern_matcher.match_deny_patterns(
-            path_str, global_patterns["deny"]
-        )
-        if is_denied:
-            return [
-                Violation(
-                    rule_id="file-placement",
-                    file_path=str(rel_path),
-                    line=1,
-                    column=0,
-                    message=reason or f"File '{rel_path}' matches denied pattern",
-                    severity=Severity.ERROR,
-                    suggestion=self._get_suggestion(rel_path.name, None),
-                )
-            ]
-        return []
-
-    def _check_global_allow_patterns(
-        self, path_str: str, rel_path: Path, global_patterns: dict[str, Any]
-    ) -> list[Violation]:
-        """Check global allow patterns."""
-        if "allow" not in global_patterns:
-            return []
-
-        if not self.pattern_matcher.match_allow_patterns(path_str, global_patterns["allow"]):
-            return [
-                Violation(
-                    rule_id="file-placement",
-                    file_path=str(rel_path),
-                    line=1,
-                    column=0,
-                    message=f"File '{rel_path}' does not match any allowed patterns",
-                    severity=Severity.ERROR,
-                    suggestion="Ensure file matches project structure patterns",
-                )
-            ]
-        return []
-
-    def _check_global_patterns(
-        self, path_str: str, rel_path: Path, global_patterns: dict[str, Any]
-    ) -> list[Violation]:
-        """Check file against global patterns.
+    def _detect_project_root(self, context: BaseLintContext) -> Path:
+        """Detect project root from file path.
 
         Args:
-            path_str: File path string
-            rel_path: Relative path
-            global_patterns: Global patterns config
+            context: Lint context
 
         Returns:
-            List of violations
+            Detected project root directory path
         """
-        deny_violations = self._check_global_deny_patterns(path_str, rel_path, global_patterns)
-        if deny_violations:
-            return deny_violations
+        from src.utils.project_root import get_project_root
 
-        return self._check_global_allow_patterns(path_str, rel_path, global_patterns)
+        if context.file_path is None:
+            return Path.cwd()
 
-    def _suggest_for_test_file(self, filename: str) -> str | None:
-        """Get suggestion for test files."""
-        if "test" in filename.lower():
-            return "Move to tests/ directory"
-        return None
+        start_path = context.file_path.parent if context.file_path.is_file() else context.file_path
+        return get_project_root(start_path)
 
-    def _suggest_for_typescript_file(self, filename: str) -> str | None:
-        """Get suggestion for TypeScript/JSX files."""
-        if filename.endswith((".ts", ".tsx", ".jsx")):
-            if "component" in filename.lower():
-                return "Move to src/components/"
-            return "Move to src/"
-        return None
+    def _extract_inline_config(self, context: BaseLintContext | None) -> dict[str, Any] | None:
+        """Extract file-placement config from context metadata.
 
-    def _suggest_for_other_files(self, filename: str) -> str:
-        """Get suggestion for other file types."""
-        if filename.endswith(".py"):
-            return "Move to src/"
-        if filename.startswith(("debug", "temp")):
-            return "Move to debug/ or remove if not needed"
-        if filename.endswith(".log"):
-            return "Move to logs/ or add to .gitignore"
-        return "Review file organization and move to appropriate directory"
-
-    def _get_suggestion(self, filename: str, current_location: str | None) -> str:
-        """Get suggestion for file placement.
+        Handles both wrapped format: {"file-placement": {...}}
+        and unwrapped format: {"global_deny": [...], "directories": {...}, ...}
 
         Args:
-            filename: File name
-            current_location: Current directory location
+            context: Lint context
 
         Returns:
-            Suggestion string
+            File placement config dict, or None if no config in metadata
         """
-        suggestion = self._suggest_for_test_file(filename)
-        if suggestion:
-            return suggestion
+        if not self._has_valid_metadata(context):
+            return None
 
-        suggestion = self._suggest_for_typescript_file(filename)
-        if suggestion:
-            return suggestion
+        # Type narrowing: _has_valid_metadata ensures context is not None
+        # by checking: context and hasattr(context, "metadata") and context.metadata
+        if context is None:
+            return None  # Should never happen after _has_valid_metadata check
 
-        return self._suggest_for_other_files(filename)
+        # Check for wrapped format first
+        wrapped_config = self._get_wrapped_config(context)
+        if wrapped_config is not None:
+            return wrapped_config
 
-    def check_file_allowed(self, file_path: Path) -> bool:
-        """Check if file is allowed (no violations).
+        # Check for unwrapped format
+        return self._get_unwrapped_config(context)
+
+    def _has_valid_metadata(self, context: BaseLintContext | None) -> bool:
+        """Check if context has valid metadata.
 
         Args:
-            file_path: File to check
+            context: Lint context
 
         Returns:
-            True if file is allowed (no violations)
+            True if context has metadata dict
         """
-        violations = self.lint_path(file_path)
-        return len(violations) == 0
+        return bool(context and hasattr(context, "metadata") and context.metadata)
 
-    def lint_directory(self, dir_path: Path, recursive: bool = True) -> list[Violation]:
-        """Lint all files in directory.
+    @staticmethod
+    def _get_wrapped_config(context: BaseLintContext) -> dict[str, Any] | None:
+        """Get config from wrapped format: {"file-placement": {...}} or {"file_placement": {...}}.
+
+        Supports both hyphenated and underscored keys for backward compatibility.
 
         Args:
-            dir_path: Directory to scan
-            recursive: Scan recursively
+            context: Lint context with metadata
 
         Returns:
-            List of all violations found
+            Config dict or None if not in wrapped format
         """
-        from src.linter_config.ignore import IgnoreDirectiveParser
-
-        ignore_parser = IgnoreDirectiveParser(self.project_root)
-        pattern = "**/*" if recursive else "*"
-
-        violations = []
-        for file_path in dir_path.glob(pattern):
-            if not file_path.is_file():
-                continue
-            file_violations = self._lint_file_if_not_ignored(file_path, ignore_parser)
-            violations.extend(file_violations)
+        if not hasattr(context, "metadata"):
+            return None
+        # Try hyphenated format first (original format)
+        if "file-placement" in context.metadata:
+            return context.metadata["file-placement"]
+        # Try underscored format (normalized format)
+        if "file_placement" in context.metadata:
+            return context.metadata["file_placement"]
+        return None
 
-        return violations
+    @staticmethod
+    def _get_unwrapped_config(context: BaseLintContext) -> dict[str, Any] | None:
+        """Get config from unwrapped format: {"directories": {...}, ...}.
 
-    def _lint_file_if_not_ignored(self, file_path: Path, ignore_parser: Any) -> list[Violation]:
-        """Lint file if not ignored."""
-        if ignore_parser.is_ignored(file_path):
-            return []
-        return self.lint_path(file_path)
+        Args:
+            context: Lint context with metadata
 
+        Returns:
+            Config dict or None if not in unwrapped format
+        """
+        if not hasattr(context, "metadata"):
+            return None
 
-class FilePlacementRule(BaseLintRule):
-    """File placement linting rule (integrates with framework)."""
+        config_keys = {"directories", "global_deny", "global_allow", "global_patterns"}
+        matching_keys = {k: v for k, v in context.metadata.items() if k in config_keys}
+        return matching_keys if matching_keys else None
 
-    def __init__(self, config: dict[str, Any] | None = None):
-        """Initialize rule with config.
+    def _get_or_create_linter(
+        self, project_root: Path, context: BaseLintContext | None = None
+    ) -> FilePlacementLinter:
+        """Get cached linter or create new one.
 
         Args:
-            config: Rule configuration
+            project_root: Project root directory
+            context: Lint context (to extract inline config if present)
+
+        Returns:
+            FilePlacementLinter instance
         """
-        self.config = config or {}
-        self._linter_cache: dict[Path, FilePlacementLinter] = {}
+        # Check if cached linter exists for this project root
+        if project_root in self._linter_cache:
+            return self._linter_cache[project_root]
 
-    @property
-    def rule_id(self) -> str:
-        """Return rule ID."""
-        return "file-placement"
+        # Try to get config from context metadata (orchestrator passes config here)
+        config_from_metadata = self._extract_inline_config(context) if context else None
 
-    @property
-    def rule_name(self) -> str:
-        """Return rule name."""
-        return "File Placement"
+        if config_from_metadata:
+            # Use config from orchestrator's metadata
+            linter = FilePlacementLinter(config_obj=config_from_metadata, project_root=project_root)
+        else:
+            # Fall back to loading from file
+            layout_path = self._get_layout_path(project_root)
+            layout_config = self._load_layout_config(layout_path)
+            linter = FilePlacementLinter(config_obj=layout_config, project_root=project_root)
 
-    @property
-    def description(self) -> str:
-        """Return rule description."""
-        return "Validate file organization against project structure rules"
+        # Cache the linter
+        self._linter_cache[project_root] = linter
+        return linter
 
     def _get_layout_path(self, project_root: Path) -> Path:
-        """Get layout config file path."""
+        """Get layout config file path.
+
+        Args:
+            project_root: Project root directory
+
+        Returns:
+            Path to layout config file
+        """
         layout_file = self.config.get("layout_file")
         if layout_file:
             return project_root / layout_file
 
-        yaml_path = project_root / ".ai" / "layout.yaml"
-        json_path = project_root / ".ai" / "layout.json"
-        if yaml_path.exists():
-            return yaml_path
-        if json_path.exists():
-            return json_path
-        return yaml_path
-
-    def _load_layout_config(self, layout_path: Path) -> dict[str, Any]:
-        """Load layout configuration from file."""
-        try:
-            return self._parse_layout_file(layout_path)
-        except Exception:
-            return {}
+        # Check for standard config files at project root
+        thailint_yaml = project_root / ".thailint.yaml"
+        thailint_json = project_root / ".thailint.json"
 
-    def _parse_layout_file(self, layout_path: Path) -> dict[str, Any]:
-        """Parse layout file based on extension."""
-        with layout_path.open(encoding="utf-8") as f:
-            if str(layout_path).endswith((".yaml", ".yml")):
-                return yaml.safe_load(f) or {}
-            return json.load(f)
+        for path in [thailint_yaml, thailint_json]:
+            if path.exists():
+                return path
 
-    def _get_or_create_linter(self, project_root: Path) -> FilePlacementLinter:
-        """Get cached linter or create new one."""
-        if project_root not in self._linter_cache:
-            layout_path = self._get_layout_path(project_root)
-            layout_config = self._load_layout_config(layout_path)
-            self._linter_cache[project_root] = FilePlacementLinter(
-                config_obj=layout_config, project_root=project_root
-            )
-        return self._linter_cache[project_root]
+        # Return default path if no config exists
+        return thailint_yaml
 
-    def check(self, context: BaseLintContext) -> list[Violation]:
-        """Check file placement.
+    def _load_layout_config(self, layout_path: Path) -> dict[str, Any]:
+        """Load layout configuration from file.
 
         Args:
-            context: Lint context
+            layout_path: Path to layout file
 
         Returns:
-            List of violations
+            Layout configuration dict (unwrapped from file-placement key), or empty dict on error
         """
-        if not context.file_path:
-            return []
+        try:
+            config = self._parse_layout_file(layout_path)
 
-        project_root = self._find_project_root(context.file_path)
-        linter = self._get_or_create_linter(project_root)
-        return linter.lint_path(context.file_path)
+            # Unwrap file-placement key if present (try both formats for backward compatibility)
+            if "file-placement" in config:
+                return config["file-placement"]
+            if "file_placement" in config:
+                return config["file_placement"]
+
+            return config
+        except Exception:
+            return {}
 
-    def _find_project_root(self, file_path: Path) -> Path:
-        """Find project root by looking for .ai directory.
+    def _parse_layout_file(self, layout_path: Path) -> dict[str, Any]:
+        """Parse layout file based on extension.
 
         Args:
-            file_path: File being linted
+            layout_path: Path to layout file
 
         Returns:
-            Project root directory
+            Parsed configuration dict
         """
-        current = file_path.parent if file_path.is_file() else file_path
-
-        # Walk up directory tree looking for .ai directory
-        while current != current.parent:
-            if (current / ".ai").exists():
-                return current
-            current = current.parent
-
-        # Fallback to current directory if no .ai found
-        return Path.cwd()
+        with layout_path.open(encoding="utf-8") as f:
+            if str(layout_path).endswith((".yaml", ".yml")):
+                return yaml.safe_load(f) or {}
+            return json.load(f)