thailint 0.1.0__py3-none-any.whl

src/.ai/layout.yaml

@@ -0,0 +1,48 @@
+file-placement:
+  directories:
+    .ai:
+      allow:
+      - .*\\.(md|yaml|yml)$
+    .roadmap:
+      allow:
+      - .*\\.md$
+    docs:
+      allow:
+      - .*\\.(md|rst|txt|py)$
+      deny:
+      - ^(?!.*\\.(md|rst|txt|py)$).*
+    src:
+      allow:
+      - .*\\.py$
+      deny:
+      - test_.*\\.py$
+      - .*_test\\.py$
+    tests:
+      allow:
+      - test_.*\\.py$
+      - .*_test\\.py$
+      - conftest\\.py$
+      - __init__\\.py$
+      deny:
+      - ^(?!test_|.*_test\\.py|conftest\\.py|__init__\\.py).*\\.py$
+  global_patterns:
+    deny:
+    - message: Python files should be in src/, tests/, scripts/, docs/, .ai/, or .roadmap/
+        directories
+      pattern: ^(?!src/|tests/|scripts/|docs/|\\.ai/|\\.roadmap/).*\\.py$
+  ignore:
+  - __pycache__/
+  - '*.pyc'
+  - .git/
+  - .venv/
+  - venv/
+  - .pytest_cache/
+  - .mypy_cache/
+  - .ruff_cache/
+  - htmlcov/
+  - '*.egg-info/'
+  - dist/
+  - build/
+nesting:
+  enabled: true
+  max_nesting_depth: 3

src/__init__.py

@@ -0,0 +1,49 @@
+"""
+Purpose: Package initialization and version definition for CLI application
+
+Scope: Package-level exports and metadata
+
+Overview: Initializes the CLI application package, defines version number using semantic versioning,
+    and exports the public API. Provides single source of truth for version information used by
+    setup tools, CLI help text, and documentation. Exports main CLI entry point, high-level Linter
+    class for library usage, configuration utilities, and direct linter imports for advanced usage.
+    Includes nesting depth linter exports for convenient access to nesting analysis functionality.
+
+Dependencies: None (minimal imports for package initialization)
+
+Exports: __version__, Linter (high-level API), cli (CLI entry point), load_config, save_config,
+    ConfigError, Orchestrator (advanced usage), file_placement_lint, nesting_lint, NestingDepthRule
+
+Interfaces: Package version string, Linter class API, CLI command group, configuration functions
+"""
+
+__version__ = "0.1.0"
+
+# High-level Library API (primary interface)
+from src.api import Linter
+
+# CLI interface
+from src.cli import cli
+from src.config import ConfigError, load_config, save_config
+
+# Advanced/direct imports (backwards compatibility)
+from src.linters.file_placement import lint as file_placement_lint
+from src.linters.nesting import NestingDepthRule
+from src.linters.nesting import lint as nesting_lint
+from src.orchestrator.core import Orchestrator
+
+__all__ = [
+    "__version__",
+    # Primary Library API
+    "Linter",
+    # CLI
+    "cli",
+    "load_config",
+    "save_config",
+    "ConfigError",
+    # Advanced/direct usage (backwards compatibility)
+    "Orchestrator",
+    "file_placement_lint",
+    "nesting_lint",
+    "NestingDepthRule",
+]

src/api.py

@@ -0,0 +1,118 @@
+"""
+Purpose: High-level Library API providing clean programmatic interface for thailint
+
+Scope: Public API for library usage without CLI, supporting configuration and linting operations
+
+Overview: Provides high-level Linter class that serves as the primary entry point for using
+    thailint as a library in other Python applications. Wraps the Orchestrator with a clean,
+    user-friendly API that handles configuration loading, path normalization, rule filtering,
+    and violation collection. Supports initialization with config files or project roots,
+    autodiscovery of .thailint.yaml/.thailint.json in project directory, and flexible linting
+    with optional rule filtering. Designed for embedding in editors, CI/CD pipelines, testing
+    frameworks, and automation tools. Maintains backwards compatibility with existing direct
+    imports while providing improved ergonomics for library users.
+
+Dependencies: pathlib for path handling, Orchestrator from orchestrator.core for linting engine,
+    LinterConfigLoader from linter_config.loader for configuration, Violation from core.types
+
+Exports: Linter class as primary library API
+
+Interfaces: Linter(config_file=None, project_root=None) initialization,
+    lint(path, rules=None) -> list[Violation] method
+
+Implementation: Thin wrapper around Orchestrator with enhanced configuration handling,
+    path normalization (str/Path support), rule filtering by name, and graceful error handling
+"""
+
+from pathlib import Path
+
+from src.core.types import Violation
+from src.linter_config.loader import LinterConfigLoader
+from src.orchestrator.core import Orchestrator
+
+
+class Linter:
+    """High-level linter API for programmatic usage.
+
+    Provides clean interface for using thailint as a library without CLI.
+    Supports configuration files, project root detection, and rule filtering.
+
+    Example:
+        >>> from src import Linter
+        >>> linter = Linter(config_file='.thailint.yaml')
+        >>> violations = linter.lint('src/', rules=['file-placement'])
+    """
+
+    def __init__(
+        self,
+        config_file: str | Path | None = None,
+        project_root: str | Path | None = None,
+    ):
+        """Initialize linter with configuration.
+
+        Args:
+            config_file: Path to config file (.thailint.yaml or .thailint.json).
+                If not provided, will autodiscover in project_root.
+            project_root: Root directory of project. Defaults to current directory.
+        """
+        self.project_root = Path(project_root) if project_root else Path.cwd()
+        self.config_loader = LinterConfigLoader()
+
+        config_path = self._resolve_config_path(config_file)
+        self.config = self.config_loader.load(config_path)
+        self.orchestrator = Orchestrator(project_root=self.project_root)
+
+    def _resolve_config_path(self, config_file: str | Path | None) -> Path:
+        """Resolve configuration file path."""
+        if config_file:
+            return Path(config_file)
+
+        yaml_path = self.project_root / ".thailint.yaml"
+        if yaml_path.exists():
+            return yaml_path
+        return self.project_root / ".thailint.json"
+
+    def lint(
+        self,
+        path: str | Path,
+        rules: list[str] | None = None,
+    ) -> list[Violation]:
+        """Lint a file or directory.
+
+        Args:
+            path: Path to file or directory to lint. Accepts string or Path.
+            rules: Optional list of rule names to run. If None, runs all rules.
+                Example: ['file-placement']
+
+        Returns:
+            List of violations found.
+
+        Example:
+            >>> linter = Linter()
+            >>> violations = linter.lint('src/', rules=['file-placement'])
+            >>> for v in violations:
+            ...     print(f"{v.file_path}: {v.message}")
+        """
+        path_obj = Path(path) if isinstance(path, str) else path
+
+        if not path_obj.exists():
+            return []
+
+        violations = self._lint_path(path_obj)
+        return self._filter_violations(violations, rules)
+
+    def _lint_path(self, path_obj: Path) -> list[Violation]:
+        """Lint a path (file or directory)."""
+        if path_obj.is_file():
+            return self.orchestrator.lint_file(path_obj)
+        if path_obj.is_dir():
+            return self.orchestrator.lint_directory(path_obj, recursive=True)
+        return []
+
+    def _filter_violations(
+        self, violations: list[Violation], rules: list[str] | None
+    ) -> list[Violation]:
+        """Filter violations by rule names."""
+        if rules:
+            return [v for v in violations if v.rule_id in rules]
+        return violations