chisel-checker 0.1.1__py3-none-any.whl

chisel/__init__.py

@@ -0,0 +1,4 @@
+
+from chisel.checker import check_project
+
+__all__ = ["check_project"]

chisel/checker/__init__.py

@@ -0,0 +1,11 @@
+
+from chisel.checker.factory import CheckerFactory
+from chisel.checker.reporter import Reporter
+
+
+def check_project(project_path: str) -> None:
+    factory = CheckerFactory()
+    controller = factory.create_controller()
+    result = controller.check(project_path)
+    reporter = Reporter()
+    reporter.report(result)

chisel/checker/config.py

@@ -0,0 +1,9 @@
+
+from dataclasses import dataclass, field
+from pathlib import Path
+
+
+@dataclass(slots=True)
+class CheckerConfig:
+    target_path: Path = field(default_factory=Path.cwd)
+    strict: bool = True

chisel/checker/controllers/check_controller.py

@@ -0,0 +1,124 @@
+
+import ast
+import sys
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from chisel.checker.errors import ImportGraphError
+from chisel.checker.models.project_info import ProjectInfo
+from chisel.checker.models.result import CheckResult
+from chisel.checker.models.severity import Severity
+from chisel.checker.models.violation import Violation
+from chisel.checker.repositories.file_discovery import FileDiscovery
+from chisel.checker.repositories.file_reader import FileReader
+from chisel.checker.repositories.import_graph import ImportGraph
+from chisel.checker.repositories.protocols import IImportGraph
+from chisel.checker.services.protocols import ICheckerService, ISuppressionService
+
+
+from chisel.checker.repositories.exception_registry import ExceptionRegistry
+
+
+@dataclass(slots=True)
+class CheckController:
+    _suppression: ISuppressionService
+    _services: list[ICheckerService] = field(default_factory=list)
+    _import_graph: IImportGraph = field(default_factory=ImportGraph)  # noqa
+
+    def check(self, project_path: str) -> CheckResult:
+        root = Path(project_path).resolve()
+        project = self._prepare_project(root)
+        violations: list[Violation] = []
+
+        if project.package_name:
+            try:
+                self._build_import_graph(root, project.package_name)
+            except ImportGraphError as exc:
+                violations.append(
+                    Violation(
+                        file="<import-graph>",
+                        line=0,
+                        severity=Severity.WARNING,
+                        rule_id="import-graph:build-failed",
+                        message=str(exc),
+                    )
+                )
+
+        violations.extend(self._run_services(project))
+        violations = self._apply_exceptions(root, violations)
+        sources = self._collect_sources(project)
+        active = self._suppression.check(violations, sources)
+        return self._summarize(active, len(project.files))
+
+    def _prepare_project(self, root: Path) -> ProjectInfo:
+        discovery = FileDiscovery()
+        project = discovery.discover(root)
+        reader = FileReader()
+        populated = [
+            self._load_file(f, root, reader) for f in project.files
+        ]
+        return ProjectInfo(
+            root_path=project.root_path,
+            files=populated,
+            package_name=project.package_name,
+        )
+
+    def _load_file(
+        self, file_info, root: Path, reader: FileReader
+    ):
+        try:
+            source = reader.read(root / file_info.path)
+            return type(file_info)(
+                path=file_info.path,
+                layer=file_info.layer,
+                source=source,
+                ast_tree=ast.parse(source),
+            )
+        except Exception:
+            return file_info
+
+    def _build_import_graph(self, root: Path, package_name: str) -> None:
+        src = root / "src"
+        src_path = str(src) if src.is_dir() else str(root)
+        original_path = list(sys.path)
+        try:
+            if src_path not in sys.path:
+                sys.path.insert(0, src_path)
+            self._import_graph.build(root, package_name)
+        except Exception as exc:
+            raise ImportGraphError(
+                f"Failed to build import graph for "
+                f"'{package_name}': {exc}"
+            ) from exc
+        finally:
+            sys.path = original_path
+
+    def _run_services(self, project: ProjectInfo) -> list[Violation]:
+        violations: list[Violation] = []
+        for service in self._services:
+            violations.extend(service.check(project))
+        return violations
+
+    def _collect_sources(self, project: ProjectInfo) -> dict[str, str]:
+        return {str(f.path): f.source for f in project.files}
+
+    def _apply_exceptions(
+        self, root: Path, violations: list[Violation]
+    ) -> list[Violation]:
+        registry = ExceptionRegistry()
+        registry.load(root)
+        return registry.filter(violations)
+
+    def _summarize(
+        self, violations: list[Violation], files_checked: int
+    ) -> CheckResult:
+        errors = sum(1 for v in violations if v.severity == Severity.ERROR)
+        warnings = sum(1 for v in violations if v.severity == Severity.WARNING)
+        info = sum(1 for v in violations if v.severity == Severity.INFO)
+        return CheckResult(
+            violations=violations,
+            errors=errors,
+            warnings=warnings,
+            info=info,
+            files_checked=files_checked,
+        )

chisel/checker/errors.py

@@ -0,0 +1,16 @@
+
+
+class CheckerError(Exception):
+    pass
+
+
+class FileNotFoundError(CheckerError):
+    pass
+
+
+class ImportGraphError(CheckerError):
+    pass
+
+
+class ConfigError(CheckerError):
+    pass

chisel/checker/factory.py

@@ -0,0 +1,45 @@
+
+from dataclasses import dataclass, field
+
+from chisel.checker.controllers.check_controller import CheckController
+from chisel.checker.repositories.import_graph import ImportGraph
+from chisel.checker.repositories.protocols import IImportGraph
+from chisel.checker.services.app_file import AppFileService
+from chisel.checker.services.complexity import ComplexityService
+from chisel.checker.services.concurrency import ConcurrencyService
+from chisel.checker.services.config_startup import ConfigStartupService
+from chisel.checker.services.error_flow import ErrorFlowService
+from chisel.checker.services.import_boundary import ImportBoundaryService
+from chisel.checker.services.project_structure import ProjectStructureService
+from chisel.checker.services.protocols import ICheckerService
+from chisel.checker.services.session import SessionService
+from chisel.checker.services.structural import StructuralService
+from chisel.checker.services.suppression import SuppressionService
+from chisel.checker.services.check_test_structure import CheckTestStructureService
+
+
+@dataclass(slots=True)
+class CheckerFactory:
+    _import_graph: IImportGraph = field(default_factory=ImportGraph)
+    _suppression: SuppressionService = field(default_factory=SuppressionService)
+    strict: bool = True
+
+    def create_controller(self) -> CheckController:
+        services: list[ICheckerService] = [
+            ImportBoundaryService(_import_graph=self._import_graph),
+            StructuralService(),
+            ComplexityService(),
+            ConcurrencyService(),
+            SessionService(),
+            ErrorFlowService(),
+            ConfigStartupService(),
+            ProjectStructureService(strict=self.strict),
+            AppFileService(),
+            CheckTestStructureService(),
+        ]
+
+        return CheckController(
+            _services=services,
+            _suppression=self._suppression,
+            _import_graph=self._import_graph,
+        )

chisel/checker/models/__init__.py

@@ -0,0 +1,20 @@
+
+from chisel.checker.models.exemption import Exemption
+from chisel.checker.models.file_info import FileInfo
+from chisel.checker.models.import_edge import ImportEdge
+from chisel.checker.models.layer import Layer
+from chisel.checker.models.project_info import ProjectInfo
+from chisel.checker.models.result import CheckResult
+from chisel.checker.models.severity import Severity
+from chisel.checker.models.violation import Violation
+
+__all__ = [
+    "CheckResult",
+    "Exemption",
+    "FileInfo",
+    "ImportEdge",
+    "Layer",
+    "ProjectInfo",
+    "Severity",
+    "Violation",
+]

chisel/checker/models/exemption.py

@@ -0,0 +1,8 @@
+from dataclasses import dataclass, field
+
+
+@dataclass(frozen=True, slots=True)
+class Exemption:
+    file_patterns: list[str] = field(default_factory=list)
+    rule_ids: list[str] = field(default_factory=list)
+    reason: str = ""

chisel/checker/models/file_info.py

@@ -0,0 +1,14 @@
+
+import ast
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from chisel.checker.models.layer import Layer
+
+
+@dataclass(slots=True)
+class FileInfo:
+    path: Path
+    layer: Layer
+    source: str = ""
+    ast_tree: ast.Module | None = None

chisel/checker/models/import_edge.py

@@ -0,0 +1,10 @@
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True, slots=True)
+class ImportEdge:
+    importer: str
+    imported: str
+    line_number: int
+    line_contents: str

chisel/checker/models/layer.py

@@ -0,0 +1,19 @@
+
+from enum import Enum
+
+
+class Layer(Enum):
+    MODELS = "models"
+    ERRORS = "errors"
+    CONFIG = "config"
+    SERVICES = "services"
+    REPOSITORIES = "repositories"
+    CONTROLLERS = "controllers"
+    FACTORY = "factory"
+    ROUTES = "routes"
+    DEPENDENCIES = "dependencies"
+    ERROR_HANDLERS = "error_handlers"
+    APP_FILE = "app_file"
+    UTILS = "utils"
+    TESTS = "tests"
+    UNKNOWN = "unknown"

chisel/checker/models/project_info.py

@@ -0,0 +1,12 @@
+
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from chisel.checker.models.file_info import FileInfo
+
+
+@dataclass(slots=True)
+class ProjectInfo:
+    root_path: Path
+    files: list[FileInfo] = field(default_factory=list)
+    package_name: str = ""

chisel/checker/models/result.py

@@ -0,0 +1,17 @@
+
+from dataclasses import dataclass, field
+
+from chisel.checker.models.violation import Violation
+
+
+@dataclass(frozen=True, slots=True)
+class CheckResult:
+    violations: list[Violation] = field(default_factory=list)
+    errors: int = 0
+    warnings: int = 0
+    info: int = 0
+    files_checked: int = 0
+
+    @property
+    def has_errors(self) -> bool:
+        return self.errors > 0

chisel/checker/models/severity.py

@@ -0,0 +1,8 @@
+
+from enum import Enum
+
+
+class Severity(Enum):
+    ERROR = "error"
+    WARNING = "warning"
+    INFO = "info"

chisel/checker/models/violation.py

@@ -0,0 +1,13 @@
+
+from dataclasses import dataclass
+
+from chisel.checker.models.severity import Severity
+
+
+@dataclass(frozen=True, slots=True)
+class Violation:
+    file: str
+    line: int
+    severity: Severity
+    rule_id: str
+    message: str

chisel/checker/reporter.py

@@ -0,0 +1,70 @@
+
+import json
+from dataclasses import dataclass
+
+from rich.console import Console
+from rich.table import Table
+
+from chisel.checker.models.result import CheckResult
+from chisel.checker.models.severity import Severity
+from chisel.checker.models.violation import Violation
+
+
+@dataclass(slots=True)
+class Reporter:
+    _console: Console = Console()
+
+    def report(self, result: CheckResult) -> None:
+        table = Table(title="Chisel Architecture Check")
+        table.add_column("File", style="cyan", no_wrap=False)
+        table.add_column("Line", style="dim", justify="right")
+        table.add_column("Severity")
+        table.add_column("Rule")
+        table.add_column("Message", style="white")
+
+        for v in result.violations:
+            sev = self._severity_label(v.severity)
+            table.add_row(
+                v.file,
+                str(v.line),
+                sev,
+                v.rule_id,
+                v.message,
+            )
+
+        self._console.print(table)
+
+        self._console.print(
+            f"\n[fine]: {result.files_checked} files checked | "
+            f"[red]{result.errors} errors[/red] | "
+            f"[yellow]{result.warnings} warnings[/yellow] | "
+            f"[blue]{result.info} info[/blue]"
+        )
+
+    def report_json(self, result: CheckResult) -> str:
+        data = {
+            "summary": {
+                "files_checked": result.files_checked,
+                "errors": result.errors,
+                "warnings": result.warnings,
+                "info": result.info,
+            },
+            "violations": [
+                {
+                    "file": v.file,
+                    "line": v.line,
+                    "severity": v.severity.value,
+                    "rule_id": v.rule_id,
+                    "message": v.message,
+                }
+                for v in result.violations
+            ],
+        }
+        return json.dumps(data, indent=2)
+
+    def _severity_label(self, severity: Severity) -> str:
+        if severity == Severity.ERROR:
+            return "[red]ERROR[/red]"
+        if severity == Severity.WARNING:
+            return "[yellow]WARNING[/yellow]"
+        return "[blue]INFO[/blue]"

chisel/checker/repositories/exception_registry.py

@@ -0,0 +1,60 @@
+import fnmatch
+from dataclasses import dataclass, field
+from pathlib import Path
+
+try:
+    import tomllib
+except ImportError:
+    import tomli as tomllib
+
+from chisel.checker.models.exemption import Exemption
+
+
+@dataclass(slots=True)
+class ExceptionRegistry:
+    _exemptions: list[Exemption] = field(default_factory=list)
+
+    def load(self, root: Path) -> None:
+        config_path = root / "chisel-exceptions.toml"
+        if not config_path.exists():
+            return
+        data = tomllib.loads(config_path.read_text(encoding="utf-8"))
+        for entry in data.get("exceptions", []):
+            self._exemptions.append(
+                Exemption(
+                    file_patterns=list(entry.get("files", [])),
+                    rule_ids=list(entry.get("rules", [])),
+                    reason=entry.get("reason", ""),
+                )
+            )
+
+    def is_exempted(self, file: str, rule_id: str) -> bool:
+        for exemption in self._exemptions:
+            if not self._file_matches(file, exemption.file_patterns):
+                continue
+            if not self._rule_matches(rule_id, exemption.rule_ids):
+                continue
+            return True
+        return False
+
+    def _file_matches(self, file: str, patterns: list[str]) -> bool:
+        for pattern in patterns:
+            if fnmatch.fnmatch(file, pattern):
+                return True
+        return False
+
+    def _rule_matches(self, rule_id: str, rules: list[str]) -> bool:
+        for rule in rules:
+            if rule == "*":
+                return True
+            if rule_id == rule:
+                return True
+            if rule_id.startswith(rule + ":") or rule_id.startswith(rule + "."):
+                return True
+        return False
+
+    def filter(self, violations: list) -> list:
+        return [
+            v for v in violations
+            if not self.is_exempted(v.file, v.rule_id)
+        ]

chisel/checker/repositories/file_discovery.py

@@ -0,0 +1,119 @@
+
+from dataclasses import dataclass
+from pathlib import Path
+
+from chisel.checker.models.file_info import FileInfo
+from chisel.checker.models.layer import Layer
+from chisel.checker.models.project_info import ProjectInfo
+
+
+@dataclass(slots=True)
+class FileDiscovery:
+    _LAYER_MAP = {
+        "models": Layer.MODELS,
+        "errors": Layer.ERRORS,
+        "config": Layer.CONFIG,
+        "services": Layer.SERVICES,
+        "repositories": Layer.REPOSITORIES,
+        "controllers": Layer.CONTROLLERS,
+        "factory": Layer.FACTORY,
+        "routes": Layer.ROUTES,
+        "dependencies": Layer.DEPENDENCIES,
+        "error_handlers": Layer.ERROR_HANDLERS,
+        "utils": Layer.UTILS,
+        "tests": Layer.TESTS,
+        "app": Layer.APP_FILE,
+    }
+
+    _LAYER_FILENAMES = {
+        "errors.py": Layer.ERRORS,
+        "config.py": Layer.CONFIG,
+        "factory.py": Layer.FACTORY,
+        "dependencies.py": Layer.DEPENDENCIES,
+        "error_handlers.py": Layer.ERROR_HANDLERS,
+        "app.py": Layer.APP_FILE,
+    }
+
+    def discover(self, root_path: Path) -> ProjectInfo:
+        root_path = root_path.resolve()
+        package_name = self._find_package_name(root_path)
+        src_root = self._find_src_root(root_path, package_name)
+
+        files: list[FileInfo] = []
+        for py_file in sorted(src_root.rglob("*.py")):
+            if self._is_ignored(py_file, src_root):
+                continue
+            relative = py_file.relative_to(root_path)
+            layer = self._classify_file(py_file, src_root, package_name)
+            files.append(FileInfo(path=relative, layer=layer))
+
+        tests_root = root_path / "tests"
+        if tests_root.is_dir():
+            for py_file in sorted(tests_root.rglob("*.py")):
+                if self._is_ignored(py_file, tests_root):
+                    continue
+                relative = py_file.relative_to(root_path)
+                files.append(FileInfo(path=relative, layer=Layer.TESTS))
+
+        return ProjectInfo(root_path=root_path, files=files, package_name=package_name)
+
+    def _find_package_name(self, root_path: Path) -> str:
+        src = root_path / "src"
+        if src.is_dir():
+            for child in sorted(src.iterdir()):
+                if child.is_dir() and (child / "__init__.py").exists():
+                    return child.name
+
+        for child in sorted(root_path.iterdir()):
+            if not child.is_dir():
+                continue
+            if child.name in ("tests", "__pycache__", ".mypy_cache", ".venv", "venv", "node_modules"):
+                continue
+            if child.name.startswith("."):
+                continue
+            if (child / "__init__.py").exists():
+                return child.name
+
+        return ""
+
+    def _find_src_root(self, root_path: Path, package_name: str) -> Path:
+        if package_name:
+            candidate = root_path / "src" / package_name
+            if candidate.is_dir():
+                return candidate
+            candidate = root_path / package_name
+            if candidate.is_dir():
+                return candidate
+        src = root_path / "src"
+        if src.is_dir():
+            return src
+        return root_path
+
+    def _classify_file(self, file_path: Path, src_root: Path, package_name: str) -> Layer:
+        relative = file_path.relative_to(src_root)
+
+        filename = file_path.name
+        if filename in self._LAYER_FILENAMES:
+            return self._LAYER_FILENAMES[filename]
+
+        parents = [p.name for p in file_path.parents if str(p) != str(src_root)]
+        parts = relative.parts
+
+        for part in parts[:-1]:
+            if part in self._LAYER_MAP:
+                return self._LAYER_MAP[part]
+
+        for part in reversed(parts[:-1]):
+            if part in self._LAYER_MAP:
+                return self._LAYER_MAP[part]
+
+        return Layer.UNKNOWN
+
+    def _is_ignored(self, path: Path, src_root: Path) -> bool:
+        parts = path.parts
+        for part in parts:
+            if part.startswith(".") or part in ("__pycache__", "node_modules", ".venv", "venv"):
+                return True
+            if part == "migrations":
+                return True
+        return False

chisel/checker/repositories/file_reader.py

@@ -0,0 +1,8 @@
+from dataclasses import dataclass
+from pathlib import Path
+
+
+@dataclass(slots=True)
+class FileReader:
+    def read(self, path: Path) -> str:
+        return path.read_text(encoding="utf-8")