ps-plugin-module-check 0.2.9__tar.gz

ps_plugin_module_check-0.2.9/PKG-INFO

@@ -0,0 +1,123 @@
+Metadata-Version: 2.4
+Name: ps-plugin-module-check
+Version: 0.2.9
+Summary: Check module for ps-poetry: configurable quality checks including ruff, pyright, pytest, and more
+Author: ztBlackGad
+Requires-Python: >=3.10,<3.14
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: ps-dependency-injection (>=0.2.9,<0.3.0)
+Project-URL: Homepage, https://github.com/BlackGad/ps-poetry
+Project-URL: Repository, https://github.com/BlackGad/ps-poetry
+Description-Content-Type: text/markdown
+
+# Overview
+
+The `ps-plugin-module-check` module extends Poetry's built-in `check` command with a configurable sequence of quality checks across all projects in a monorepo. It provides seven built-in checkers — `poetry`, `environment`, `imports`, `ruff`, `pylint`, `pytest`, and `pyright` — with support for automatic fixing and per-project configuration.
+
+The module is registered as a `ps.module` entry point and activates when included in the host project's `[tool.ps-plugin]` configuration.
+
+# Installation
+
+```bash
+pip install ps-plugin-module-check
+```
+
+Or with Poetry:
+
+```bash
+poetry add ps-plugin-module-check
+```
+
+Enable it in the plugin configuration:
+
+```toml
+[tool.ps-plugin]
+modules = ["ps-check"]
+```
+
+# Quick Start
+
+Run all configured checks across all projects:
+
+```bash
+poetry check
+```
+
+Run checks on specific projects with automatic fixing:
+
+```bash
+poetry check my-package --fix
+```
+
+# Configuration
+
+The module reads its settings from the `[tool.ps-plugin]` section of the host project's `pyproject.toml`. The `checks` field specifies which checkers to run and in what order.
+
+```toml
+[tool.ps-plugin]
+checks = ["poetry", "environment", "ruff", "pytest"]
+```
+
+When `checks` is omitted or empty, no checkers are selected and the command exits immediately. Only checkers listed in `checks` are executed, and they run in the declared order.
+
+# Command-Line Usage
+
+The module extends Poetry's `check` command with additional arguments and options:
+
+```bash
+poetry check [INPUTS...] [--fix] [--continue-on-error]
+```
+
+* `INPUTS` — Optional list of project names or paths to check. When omitted, all discovered projects are checked. When running from a sub-project that differs from the host project, the sub-project is selected automatically.
+* `--fix` / `-f` — Enable automatic fixing in checkers that support it (`ruff` and `imports`).
+* `--continue-on-error` / `-c` — Continue checking remaining projects and checkers after a failure instead of stopping on the first error.
+
+# Available Checks
+
+## poetry
+
+Runs Poetry's built-in `check` command on each target project independently, validating the `pyproject.toml` structure and metadata.
+
+## environment
+
+Validates consistency of package sources across all target projects. Detects two types of conflicts:
+
+* **URL conflicts** — The same source name (case-insensitive) is declared with different URLs in different projects.
+* **Priority conflicts** — The same source name is declared with different priority levels across projects.
+
+This checker is validation-only and does not support automatic fixing.
+
+## imports
+
+Walks each project's source directories and collects all non-stdlib, non-relative imports using AST analysis. For each import, the checker verifies that the providing distribution is declared as a dependency of the project, either directly or transitively through local path dependencies.
+
+Stdlib modules, `__future__` imports, and modules belonging to the project's own package are silently skipped. When a required distribution is not declared, the checker reports the missing dependency together with the file paths and line numbers where the import appears.
+
+When the `--fix` flag is provided, the checker adds each missing dependency automatically. Local monorepo packages are preferred over PyPI packages and are added as development dependencies with a path reference. PyPI packages are added as regular dependencies with an unconstrained version specifier. Projects are greedily consolidated so that adding a single dependency covers as many missing imports as possible through its transitive closure.
+
+## ruff
+
+Runs the `ruff` linter on the collected source paths. When the `--fix` flag is provided, the `--fix` argument is forwarded to ruff to apply automatic corrections. This checker is only available when `ruff` is installed and accessible in PATH.
+
+## pylint
+
+Runs `pylint` on the collected source paths. This checker is only available when `pylint` is installed and accessible in PATH.
+
+## pytest
+
+Runs `pytest` on the collected source paths. This checker is only available when `pytest` is installed and accessible in PATH.
+
+## pyright
+
+Runs `pyright` on the collected source paths for static type checking. This checker is only available when `pyright` is installed and accessible in PATH. Auto-fixing is not supported.
+
+# Custom Checks
+
+`ICheck` is the abstract base class for implementing custom checkers. Subclasses implement `check(io, projects, fix)` to perform the check and return an optional exception on failure. The `can_check(projects)` method allows a checker to declare itself inapplicable to a given project list. Each subclass must declare a `name: ClassVar[str]` attribute that matches the name used in the `checks` configuration list.
+
+Register custom implementations with the DI container using `di.register(ICheck)` inside `poetry_activate` so the check module discovers them automatically via `di.resolve_many(ICheck)`.
+

ps_plugin_module_check-0.2.9/README.md

@@ -0,0 +1,106 @@
+# Overview
+
+The `ps-plugin-module-check` module extends Poetry's built-in `check` command with a configurable sequence of quality checks across all projects in a monorepo. It provides seven built-in checkers — `poetry`, `environment`, `imports`, `ruff`, `pylint`, `pytest`, and `pyright` — with support for automatic fixing and per-project configuration.
+
+The module is registered as a `ps.module` entry point and activates when included in the host project's `[tool.ps-plugin]` configuration.
+
+# Installation
+
+```bash
+pip install ps-plugin-module-check
+```
+
+Or with Poetry:
+
+```bash
+poetry add ps-plugin-module-check
+```
+
+Enable it in the plugin configuration:
+
+```toml
+[tool.ps-plugin]
+modules = ["ps-check"]
+```
+
+# Quick Start
+
+Run all configured checks across all projects:
+
+```bash
+poetry check
+```
+
+Run checks on specific projects with automatic fixing:
+
+```bash
+poetry check my-package --fix
+```
+
+# Configuration
+
+The module reads its settings from the `[tool.ps-plugin]` section of the host project's `pyproject.toml`. The `checks` field specifies which checkers to run and in what order.
+
+```toml
+[tool.ps-plugin]
+checks = ["poetry", "environment", "ruff", "pytest"]
+```
+
+When `checks` is omitted or empty, no checkers are selected and the command exits immediately. Only checkers listed in `checks` are executed, and they run in the declared order.
+
+# Command-Line Usage
+
+The module extends Poetry's `check` command with additional arguments and options:
+
+```bash
+poetry check [INPUTS...] [--fix] [--continue-on-error]
+```
+
+* `INPUTS` — Optional list of project names or paths to check. When omitted, all discovered projects are checked. When running from a sub-project that differs from the host project, the sub-project is selected automatically.
+* `--fix` / `-f` — Enable automatic fixing in checkers that support it (`ruff` and `imports`).
+* `--continue-on-error` / `-c` — Continue checking remaining projects and checkers after a failure instead of stopping on the first error.
+
+# Available Checks
+
+## poetry
+
+Runs Poetry's built-in `check` command on each target project independently, validating the `pyproject.toml` structure and metadata.
+
+## environment
+
+Validates consistency of package sources across all target projects. Detects two types of conflicts:
+
+* **URL conflicts** — The same source name (case-insensitive) is declared with different URLs in different projects.
+* **Priority conflicts** — The same source name is declared with different priority levels across projects.
+
+This checker is validation-only and does not support automatic fixing.
+
+## imports
+
+Walks each project's source directories and collects all non-stdlib, non-relative imports using AST analysis. For each import, the checker verifies that the providing distribution is declared as a dependency of the project, either directly or transitively through local path dependencies.
+
+Stdlib modules, `__future__` imports, and modules belonging to the project's own package are silently skipped. When a required distribution is not declared, the checker reports the missing dependency together with the file paths and line numbers where the import appears.
+
+When the `--fix` flag is provided, the checker adds each missing dependency automatically. Local monorepo packages are preferred over PyPI packages and are added as development dependencies with a path reference. PyPI packages are added as regular dependencies with an unconstrained version specifier. Projects are greedily consolidated so that adding a single dependency covers as many missing imports as possible through its transitive closure.
+
+## ruff
+
+Runs the `ruff` linter on the collected source paths. When the `--fix` flag is provided, the `--fix` argument is forwarded to ruff to apply automatic corrections. This checker is only available when `ruff` is installed and accessible in PATH.
+
+## pylint
+
+Runs `pylint` on the collected source paths. This checker is only available when `pylint` is installed and accessible in PATH.
+
+## pytest
+
+Runs `pytest` on the collected source paths. This checker is only available when `pytest` is installed and accessible in PATH.
+
+## pyright
+
+Runs `pyright` on the collected source paths for static type checking. This checker is only available when `pyright` is installed and accessible in PATH. Auto-fixing is not supported.
+
+# Custom Checks
+
+`ICheck` is the abstract base class for implementing custom checkers. Subclasses implement `check(io, projects, fix)` to perform the check and return an optional exception on failure. The `can_check(projects)` method allows a checker to declare itself inapplicable to a given project list. Each subclass must declare a `name: ClassVar[str]` attribute that matches the name used in the `checks` configuration list.
+
+Register custom implementations with the DI container using `di.register(ICheck)` inside `poetry_activate` so the check module discovers them automatically via `di.resolve_many(ICheck)`.

ps_plugin_module_check-0.2.9/pyproject.toml

@@ -0,0 +1,33 @@
+[project]
+name        = "ps-plugin-module-check"
+description = "Check module for ps-poetry: configurable quality checks including ruff, pyright, pytest, and more"
+readme      = "README.md"
+requires-python = ">=3.10,<3.14"
+version = "0.2.9"
+authors = [
+    { name = "ztBlackGad" },
+]
+
+[project.urls]
+Homepage   = "https://github.com/BlackGad/ps-poetry"
+Repository = "https://github.com/BlackGad/ps-poetry"
+
+[project.entry-points."ps.module"]
+module_entry = "ps.plugin.module.check"
+
+[tool.poetry.group.ps.dependencies]
+ps-plugin-sdk = ">=0.2.9,<0.3.0"
+
+
+[tool.poetry.dependencies]
+ps-dependency-injection = ">=0.2.9,<0.3.0"
+
+[tool.poetry]
+packages = [ { include = "ps/plugin/module/check", from = "src" } ]
+
+[tool.ps-plugin]
+host-project = "../.."
+
+[build-system]
+requires    = ["poetry-core>=1.0.0"]
+build-backend = "poetry.core.masonry.api"

ps_plugin_module_check-0.2.9/src/ps/plugin/module/check/__init__.py

@@ -0,0 +1,7 @@
+from ._check_module import CheckModule
+from ._check import ICheck
+
+__all__ = [
+    "CheckModule",
+    "ICheck",
+]

ps_plugin_module_check-0.2.9/src/ps/plugin/module/check/_check.py

@@ -0,0 +1,17 @@
+from abc import ABC, abstractmethod
+from typing import ClassVar, Optional
+
+from cleo.io.io import IO
+
+from ps.plugin.sdk.mixins import NameAwareProtocol
+from ps.plugin.sdk.project import Project
+
+
+class ICheck(NameAwareProtocol, ABC):
+    name: ClassVar[str]
+
+    def can_check(self, projects: list[Project]) -> bool:
+        return True
+
+    @abstractmethod
+    def check(self, io: IO, projects: list[Project], fix: bool) -> Optional[Exception]: ...

ps_plugin_module_check-0.2.9/src/ps/plugin/module/check/_check_module.py

@@ -0,0 +1,173 @@
+from typing import ClassVar, Optional, Type
+
+from cleo.events.console_command_event import ConsoleCommandEvent
+from cleo.events.console_terminate_event import ConsoleTerminateEvent
+from cleo.io.inputs.argument import Argument
+from cleo.io.inputs.input import Input
+from cleo.io.inputs.option import Option
+from cleo.io.io import IO
+from poetry.console.application import Application
+from poetry.console.commands.check import CheckCommand
+
+from ps.di import DI
+from ps.plugin.module.check._check import ICheck
+from ps.plugin.sdk.events import ensure_argument, ensure_option
+from ps.plugin.sdk.mixins import NameAwareProtocol
+from ps.plugin.sdk.project import Environment, Project, filter_projects
+
+from ._check_settings import CheckSettings
+from .checks import (
+    EnvironmentCheck,
+    ImportsCheck,
+    PoetryCheck,
+    PylintCheck,
+    PyrightCheck,
+    PytestCheck,
+    RuffCheck,
+)
+
+
+def _filter_checkers[T: NameAwareProtocol](available_checkers: list[T], check_settings: CheckSettings, io: IO) -> list[T]:
+    # Explicitly specified checks in settings
+    specified_checks = check_settings.checks if check_settings.checks is not None else []
+
+    # Get specified checkers in order
+    specified_checkers = sorted(
+        [checker for checker in available_checkers if checker.name in specified_checks],
+        key=lambda c: specified_checks.index(c.name)
+    )
+
+    # Get available but not specified checkers
+    available_not_specified = [
+        checker for checker in available_checkers if checker.name not in specified_checks
+    ]
+
+    # Print selected checkers only in verbose mode
+    if io.is_verbose():
+        io.write_line("<fg=magenta>Selected checkers:</> ")
+        for idx, checker in enumerate(specified_checkers, start=1):
+            io.write_line(f"  {idx}. <fg=cyan>{checker.name}</>")
+
+    # Print available but not selected checkers in verbose mode
+    if io.is_verbose() and available_not_specified:
+        io.write_line("\n<fg=magenta>Available but not selected:</> ")
+        for checker in available_not_specified:
+            io.write_line(f"  - <fg=dark_gray>{checker.name}</>")
+
+    return specified_checkers
+
+
+def _get_inputs(input: Input) -> list[str]:
+    return input.arguments.get("inputs", [])
+
+
+def _get_fix_option(input: Input) -> bool:
+    return input.options.get("fix", False)
+
+
+def _get_continue_on_error_option(input: Input) -> bool:
+    return input.options.get("continue-on-error", False)
+
+
+def _perform_checks(di: DI, projects: list[Project], checkers: list[ICheck], fix: bool, continue_on_error: bool) -> int:
+    if not checkers:
+        return 0
+    io = di.resolve(IO)
+    assert io is not None
+    result = 0
+    for checker in checkers:
+        io.write_line(f"<fg=cyan>{checker.name.upper()}</>")
+        if not checker.can_check(projects):
+            if io.is_debug():
+                io.write_line("<fg=yellow>Skipping checker as it cannot check the provided projects in current environment.</>")
+            continue
+        exception = checker.check(io, projects, fix)
+        if exception is not None:
+            io.write_line(f"<error>{exception}</error>")
+            result = 1
+            if not continue_on_error:
+                return result
+    return result
+
+
+_builtin_checks: list[Type[ICheck]] = [
+    PoetryCheck,
+    EnvironmentCheck,
+    ImportsCheck,
+    PytestCheck,
+    PylintCheck,
+    RuffCheck,
+    PyrightCheck,
+]
+
+
+class CheckModule:
+    name: ClassVar[str] = "ps-check"
+
+    def __init__(self, di: DI) -> None:
+        for check_cls in _builtin_checks:
+            di.register(ICheck).implementation(check_cls)
+        self._di = di
+        self._exit_code: Optional[int] = None
+
+    def poetry_activate(self, application: Application) -> bool:
+        ensure_argument(CheckCommand, Argument(
+            name="inputs",
+            description="Optional inputs pointers to check. It could be project names or paths. If not provided, all discovered projects will be checked.",
+            is_list=True,
+            required=False)
+        )
+        ensure_option(CheckCommand, Option(
+            name="fix",
+            description="Instruct to perform automatic issues fix where possible.",
+            shortcut="f",
+            flag=True)
+        )
+        ensure_option(CheckCommand, Option(
+            name="continue-on-error",
+            description="Continue checking even after a check failure.",
+            shortcut="c",
+            flag=True)
+        )
+        return True
+
+    def poetry_command(self, event: ConsoleCommandEvent) -> None:
+        if not isinstance(event.command, CheckCommand):
+            return
+        event.disable_command()
+
+        environment = self._di.resolve(Environment)
+        assert environment is not None
+
+        inputs = _get_inputs(event.io.input)
+        if not inputs and environment.host_project != environment.entry_project:
+            inputs.append(str(environment.entry_project.path))
+
+        filtered_projects = filter_projects(inputs, environment.projects)
+        if not filtered_projects:
+            event.io.write_line("<comment>No projects found to process.</comment>")
+            return
+
+        fix = _get_fix_option(event.io.input)
+        continue_on_error = _get_continue_on_error_option(event.io.input)
+
+        plugin_settings = environment.host_project.plugin_settings
+        check_settings = CheckSettings.model_validate(plugin_settings.model_dump(), by_alias=True)
+
+        available_checkers = self._di.resolve_many(ICheck)
+        checkers = _filter_checkers(available_checkers, check_settings, event.io)
+
+        if not checkers:
+            event.io.write_line("<comment>No checkers selected to run.</comment>")
+            return
+
+        if fix:
+            event.io.write_line("<fg=green>Automatic fix enabled</>")
+        if continue_on_error:
+            event.io.write_line("<fg=magenta>Continue on error enabled</>")
+        event.io.write_line(f"\n<fg=magenta>Checking <comment>{len(filtered_projects)}</comment> project(s)</>")
+        self._exit_code = _perform_checks(self._di, filtered_projects, checkers, fix, continue_on_error)
+
+    def poetry_terminate(self, event: ConsoleTerminateEvent) -> None:
+        if self._exit_code is not None:
+            event.set_exit_code(self._exit_code)

ps_plugin_module_check-0.2.9/src/ps/plugin/module/check/_check_settings.py

@@ -0,0 +1,6 @@
+from typing import Optional
+from pydantic import BaseModel, Field
+
+
+class CheckSettings(BaseModel):
+    checks: Optional[list[str]] = Field(default=None, alias="checks")

ps_plugin_module_check-0.2.9/src/ps/plugin/module/check/checks/__init__.py

@@ -0,0 +1,17 @@
+from ._environment_check import EnvironmentCheck
+from ._imports_check import ImportsCheck
+from ._poetry_check import PoetryCheck
+from ._pylint_check import PylintCheck
+from ._pyright_check import PyrightCheck
+from ._pytest_check import PytestCheck
+from ._ruff_check import RuffCheck
+
+__all__ = [
+    "EnvironmentCheck",
+    "ImportsCheck",
+    "PoetryCheck",
+    "PylintCheck",
+    "PyrightCheck",
+    "PytestCheck",
+    "RuffCheck",
+]

ps_plugin_module_check-0.2.9/src/ps/plugin/module/check/checks/_environment_check.py

@@ -0,0 +1,46 @@
+from typing import ClassVar, Optional
+
+from cleo.io.io import IO
+
+from ps.plugin.module.check._check import ICheck
+from ps.plugin.sdk.project import Project
+
+
+class EnvironmentCheck(ICheck):
+    name: ClassVar[str] = "environment"
+
+    def check(self, io: IO, projects: list[Project], fix: bool) -> Optional[Exception]:
+        errors = self._check_conflicting_sources(projects)
+
+        if not errors:
+            io.write_line("Environment check passed with no errors")
+            return None
+
+        for error in errors:
+            io.write_line(f"<error>{error}</error>")
+        return Exception(f"Environment check failed with {len(errors)} error(s)")
+
+    def _check_conflicting_sources(self, projects: list[Project]) -> list[str]:
+        urls: dict[str, dict[Optional[str], list[str]]] = {}
+        priorities: dict[str, dict[Optional[str], list[str]]] = {}
+        names: dict[str, str] = {}
+
+        for project in projects:
+            project_name = project.name.value or str(project.path)
+            for source in project.sources:
+                key = source.name.lower()
+                names.setdefault(key, source.name)
+                priority = str(source.priority) if source.priority is not None else None
+                urls.setdefault(key, {}).setdefault(source.url, []).append(project_name)
+                priorities.setdefault(key, {}).setdefault(priority, []).append(project_name)
+
+        errors = []
+        for key in urls.keys() | priorities.keys():
+            for field, groups in (("urls", urls.get(key, {})), ("priorities", priorities.get(key, {}))):
+                if len(groups) > 1:
+                    lines = "\n".join(
+                        f"  - '{val}' in {', '.join(f'{p!r}' for p in projs)}"
+                        for val, projs in groups.items()
+                    )
+                    errors.append(f"Source '{names[key]}' has conflicting {field}:\n{lines}")
+        return errors

ps_plugin_module_check-0.2.9/src/ps/plugin/module/check/checks/_imports_check.py

@@ -0,0 +1,273 @@
+import ast
+import re
+import sys
+from collections import defaultdict
+from collections.abc import Mapping
+from importlib.metadata import PackageNotFoundError, packages_distributions
+from importlib.metadata import requires as metadata_requires
+from pathlib import Path
+from typing import ClassVar, Optional
+
+from cleo.io.io import IO
+
+from ps.plugin.module.check._check import ICheck
+from ps.plugin.sdk.project import Environment, Project, normalize_dist_name, dist_name_variants
+from ps.plugin.sdk.toml import TomlValue
+
+
+def _package_entries(project: Project) -> list[dict]:
+    value = TomlValue.locate(project.document, ["tool.poetry.packages"]).value
+    return [entry for entry in value or [] if isinstance(entry, dict)]
+
+
+def _collect_imports(source_dirs: list[Path]) -> dict[str, set[tuple[Path, int]]]:
+    imports: dict[str, set[tuple[Path, int]]] = defaultdict(set)
+
+    for source_dir in source_dirs:
+        for py_file in source_dir.rglob("*.py"):
+            try:
+                tree = ast.parse(py_file.read_text(encoding="utf-8"), filename=str(py_file))
+            except SyntaxError:
+                continue
+
+            for node in ast.walk(tree):
+                if isinstance(node, ast.Import):
+                    for alias in node.names:
+                        imports[alias.name].add((py_file, node.lineno))
+                elif isinstance(node, ast.ImportFrom) and node.level == 0 and node.module:
+                    imports[node.module].add((py_file, node.lineno))
+
+    return imports
+
+
+def _build_local_module_map(projects: list[Project]) -> dict[str, list[str]]:
+    result: dict[str, list[str]] = defaultdict(list)
+
+    for project in projects:
+        dist_name = project.name.value
+        if not dist_name:
+            continue
+
+        for entry in _package_entries(project):
+            include = entry.get("include")
+            if include:
+                result[include.replace("/", ".").replace("\\", ".")].append(str(dist_name))
+
+    return dict(result)
+
+
+def _build_project_lookup(projects: list[Project]) -> dict[Path, Project]:
+    lookup: dict[Path, Project] = {}
+    for project in projects:
+        lookup[project.path] = project
+        lookup[project.path.parent] = project
+    return lookup
+
+
+def _find_providers(
+    module: str,
+    local_map: Mapping[str, list[str]],
+    dist_map: Mapping[str, list[str]],
+) -> Optional[list[str]]:
+    parts = module.split(".")
+    for size in range(len(parts), 0, -1):
+        candidate = ".".join(parts[:size])
+        if providers := local_map.get(candidate) or dist_map.get(candidate):
+            return providers
+    return None
+
+
+def _collect_pypi_transitive_deps(
+    package_name: str,
+    cache: dict[str, set[str]],
+    in_progress: set[str],
+) -> set[str]:
+    key = normalize_dist_name(package_name)
+    if key in cache:
+        return cache[key]
+    if key in in_progress:
+        return set()
+
+    in_progress.add(key)
+    names: set[str] = set()
+
+    try:
+        reqs = metadata_requires(package_name) or []
+    except PackageNotFoundError:
+        cache[key] = names
+        in_progress.discard(key)
+        return names
+
+    for req_str in reqs:
+        dep_name = re.split(r"[\s\(\[;><=!]", req_str, maxsplit=1)[0].strip()
+        if not dep_name:
+            continue
+        names.update(dist_name_variants(dep_name))
+        names.update(_collect_pypi_transitive_deps(dep_name, cache, in_progress))
+
+    cache[key] = names
+    in_progress.discard(key)
+    return names
+
+
+def _collect_all_dep_names(
+    root_project: Project,
+    project_lookup: Mapping[Path, Project],
+    cache: dict[Path, set[str]],
+    pypi_cache: dict[str, set[str]],
+    in_progress: Optional[set[Path]] = None,
+) -> set[str]:
+    if root_project.path in cache:
+        return cache[root_project.path]
+
+    in_progress = in_progress or set()
+    if root_project.path in in_progress:
+        return set()
+
+    in_progress.add(root_project.path)
+    names: set[str] = set()
+    pypi_in_progress: set[str] = set()
+
+    for dep in root_project.dependencies:
+        if dep.name:
+            names.update(dist_name_variants(dep.name))
+            if not dep.path:
+                names.update(_collect_pypi_transitive_deps(dep.name, pypi_cache, pypi_in_progress))
+
+        resolved = dep.resolved_project_path
+        if dep.path and resolved and (transient := project_lookup.get(resolved)):
+            names.update(
+                _collect_all_dep_names(
+                    transient,
+                    project_lookup=project_lookup,
+                    cache=cache,
+                    pypi_cache=pypi_cache,
+                    in_progress=in_progress,
+                )
+            )
+
+    cache[root_project.path] = names
+    in_progress.discard(root_project.path)
+    return names
+
+
+class ImportsCheck(ICheck):
+    name: ClassVar[str] = "imports"
+
+    def __init__(self, environment: Environment) -> None:
+        self._environment = environment
+        self._dep_cache: dict[Path, set[str]] = {}
+        self._pypi_cache: dict[str, set[str]] = {}
+
+    def check(self, io: IO, projects: list[Project], fix: bool) -> Optional[Exception]:
+        dist_map = packages_distributions()
+        stdlib_modules = frozenset(sys.stdlib_module_names)  # type: ignore[attr-defined]
+        all_projects = list(self._environment.projects)
+        local_map = _build_local_module_map(all_projects)
+        project_lookup = _build_project_lookup(all_projects)
+        project_by_dist: dict[str, Project] = {
+            normalize_dist_name(str(p.name.value)): p
+            for p in all_projects
+            if p.name.value
+        }
+
+        total_errors = 0
+
+        for project in self._environment.sorted_projects(projects):
+            imports_map = {
+                module: locations
+                for module, locations in _collect_imports(project.source_dirs).items()
+                if module.split(".")[0] not in stdlib_modules and module.split(".")[0] != "__future__"
+            }
+
+            project_own_names = dist_name_variants(str(project.name.value)) | {normalize_dist_name(str(project.name.value))}
+            dep_names = _collect_all_dep_names(
+                project,
+                project_lookup=project_lookup,
+                cache=self._dep_cache,
+                pypi_cache=self._pypi_cache,
+            )
+
+            missing: dict[tuple[str, ...], set[tuple[Path, int]]] = defaultdict(set)
+
+            for module, locations in sorted(imports_map.items()):
+                providers = _find_providers(module, local_map, dist_map)
+                if not providers:
+                    continue
+
+                normalized_providers = {normalize_dist_name(name) for name in providers}
+                if normalized_providers & project_own_names:
+                    continue
+                if normalized_providers & dep_names:
+                    continue
+
+                missing[tuple(providers)].update(locations)
+
+            if not missing:
+                continue
+
+            io.write_line(f"  <fg=blue>{project.path}</> <fg=dark_gray>({project.name.value})</>")
+
+            if fix:
+                self._apply_fix(io, project, missing, dep_names, project_lookup, project_by_dist)
+                self._dep_cache.clear()
+            else:
+                total_errors += len(missing)
+                for providers_key, locations in sorted(missing.items()):
+                    label = providers_key[0] if len(providers_key) == 1 else " | ".join(providers_key)
+                    io.write_line(f"    <error>missing: {label!r}</error>")
+                    for py_file, line in sorted(locations):
+                        io.write_line(f"      <fg=dark_gray>{py_file}:{line}</>")
+
+        if total_errors == 0:
+            io.write_line("Imports check passed with no errors")
+            return None
+
+        io.write_line("<comment>Run with --fix to add missing dependencies automatically.</comment>")
+        return Exception(f"Imports check failed with {total_errors} missing distribution(s)")
+
+    def _apply_fix(
+        self,
+        io: IO,
+        project: Project,
+        missing: dict[tuple[str, ...], set[tuple[Path, int]]],
+        dep_names: set[str],
+        project_lookup: dict[Path, Project],
+        project_by_dist: dict[str, Project],
+    ) -> None:
+        choices: list[tuple[tuple[str, ...], str, set[str]]] = []
+        for providers_key in missing:
+            local_provider = next(
+                (p for p in providers_key if project_by_dist.get(normalize_dist_name(p))),
+                None,
+            )
+            chosen = local_provider or providers_key[0]
+            local_dep = project_by_dist.get(normalize_dist_name(chosen))
+            if local_dep:
+                coverage = dist_name_variants(chosen) | _collect_all_dep_names(
+                    local_dep, project_lookup, self._dep_cache, self._pypi_cache
+                )
+            else:
+                coverage = dist_name_variants(chosen) | _collect_pypi_transitive_deps(
+                    chosen, self._pypi_cache, set()
+                )
+            choices.append((providers_key, chosen, coverage))
+
+        choices.sort(key=lambda x: len(x[2]), reverse=True)
+
+        newly_covered: set[str] = set()
+        for providers_key, chosen, coverage in choices:
+            norm = {normalize_dist_name(p) for p in providers_key}
+            if norm & (dep_names | newly_covered):
+                continue
+
+            newly_covered.update(coverage)
+
+            local_dep = project_by_dist.get(normalize_dist_name(chosen))
+            if local_dep:
+                project.add_development_dependency(chosen, local_dep.path.parent)
+                io.write_line(f"    <info>added (local): {chosen!r}</info>")
+            else:
+                project.add_dependency(chosen, constraint="*")
+                io.write_line(f"    <info>added: {chosen!r}</info>")
+        project.save()

ps_plugin_module_check-0.2.9/src/ps/plugin/module/check/checks/_poetry_check.py

@@ -0,0 +1,30 @@
+from typing import ClassVar, Optional
+
+from cleo.io.buffered_io import BufferedIO
+from cleo.io.io import IO
+from poetry.console.commands.check import CheckCommand
+from poetry.factory import Factory
+
+from ps.plugin.module.check._check import ICheck
+from ps.plugin.sdk.project import Project
+
+
+class PoetryCheck(ICheck):
+    name: ClassVar[str] = "poetry"
+
+    def check(self, io: IO, projects: list[Project], fix: bool) -> Optional[Exception]:
+        has_errors = False
+        for project in projects:
+            project_name = project.name.value or project.path.name
+            path_suffix = f" [<fg=dark_gray>{project.path}</>]" if io.is_verbose() else ""
+            io.write_line(f"Checking <fg=blue>{project_name}</>{path_suffix}")
+            try:
+                poetry_project = Factory().create_poetry(cwd=project.path, io=io)
+                check_command = CheckCommand()
+                check_command.set_poetry(poetry_project)
+                buffered_io = BufferedIO(decorated=io.is_decorated())
+                check_command.execute(buffered_io)
+            except Exception as e:
+                io.write_line(f"  <error>{e}</error>")
+                has_errors = True
+        return Exception("Poetry check failed") if has_errors else None

ps_plugin_module_check-0.2.9/src/ps/plugin/module/check/checks/_pylint_check.py

@@ -0,0 +1,13 @@
+from pathlib import Path
+from typing import ClassVar
+
+from ._tool_check import ToolCheck
+
+
+class PylintCheck(ToolCheck):
+    name: ClassVar[str] = "pylint"
+
+    def _build_command(self, source_paths: list[Path], fix: bool) -> list[str]:
+        command = ["pylint"]
+        command.extend([str(path) for path in source_paths])
+        return command

ps_plugin_module_check-0.2.9/src/ps/plugin/module/check/checks/_pyright_check.py

@@ -0,0 +1,13 @@
+from pathlib import Path
+from typing import ClassVar
+
+from ._tool_check import ToolCheck
+
+
+class PyrightCheck(ToolCheck):
+    name: ClassVar[str] = "pyright"
+
+    def _build_command(self, source_paths: list[Path], fix: bool) -> list[str]:
+        command = ["pyright"]
+        command.extend([str(path) for path in source_paths])
+        return command

ps_plugin_module_check-0.2.9/src/ps/plugin/module/check/checks/_pytest_check.py

@@ -0,0 +1,13 @@
+from pathlib import Path
+from typing import ClassVar
+
+from ._tool_check import ToolCheck
+
+
+class PytestCheck(ToolCheck):
+    name: ClassVar[str] = "pytest"
+
+    def _build_command(self, source_paths: list[Path], fix: bool) -> list[str]:
+        command = ["pytest"]
+        command.extend([str(path) for path in source_paths])
+        return command

ps_plugin_module_check-0.2.9/src/ps/plugin/module/check/checks/_ruff_check.py

@@ -0,0 +1,15 @@
+from pathlib import Path
+from typing import ClassVar
+
+from ._tool_check import ToolCheck
+
+
+class RuffCheck(ToolCheck):
+    name: ClassVar[str] = "ruff"
+
+    def _build_command(self, source_paths: list[Path], fix: bool) -> list[str]:
+        command = ["ruff", "check"]
+        if fix:
+            command.append("--fix")
+        command.extend([str(path) for path in source_paths])
+        return command

ps_plugin_module_check-0.2.9/src/ps/plugin/module/check/checks/_tool_check.py

@@ -0,0 +1,66 @@
+import shutil
+import subprocess
+from abc import abstractmethod
+from pathlib import Path
+from typing import Optional
+
+from cleo.io.io import IO
+
+from ps.plugin.module.check._check import ICheck
+from ps.di import DI
+from ps.plugin.sdk.project import Environment, Project
+
+
+def _collect_source_paths(projects: list[Project]) -> list[Path]:
+    all_paths = sorted(
+        {project.path.parent for project in projects},
+        key=lambda p: len(p.parts),
+    )
+    source_paths: list[Path] = []
+    for path in all_paths:
+        if not any(
+            path != parent and path.is_relative_to(parent)
+            for parent in source_paths
+        ):
+            source_paths.append(path)
+    return source_paths
+
+
+class ToolCheck(ICheck):
+    def __init__(self, di: DI) -> None:
+        self._di = di
+
+    def can_check(self, projects: list[Project]) -> bool:
+        return shutil.which(self.name) is not None
+
+    @abstractmethod
+    def _build_command(self, source_paths: list[Path], fix: bool) -> list[str]: ...
+
+    def check(self, io: IO, projects: list[Project], fix: bool) -> Optional[Exception]:
+        environment = self._di.resolve(Environment)
+        assert environment is not None
+
+        source_paths = _collect_source_paths(projects)
+        if not source_paths:
+            io.write_line("No source paths found.")
+            return None
+
+        command = self._build_command(source_paths, fix)
+        io.write_line(f"Running command: {' '.join(command)}")
+
+        cwd = environment.host_project.path.parent
+        process = subprocess.Popen(  # noqa: S603
+            command,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            text=True,
+            encoding="utf-8",
+            cwd=cwd,
+        )
+        if process.stdout:
+            for line in iter(process.stdout.readline, ""):
+                io.write(line)
+        process.wait()
+        if process.returncode != 0:
+            return Exception(f"{self.name.capitalize()} check failed with exit code {process.returncode}")
+        return None