py-code-quality-guard 0.1.0__py3-none-any.whl

code_quality_guard/__init__.py

@@ -0,0 +1,3 @@
+"""Automated quality gates for Python projects."""
+
+__version__ = "0.1.0"

code_quality_guard/__main__.py

@@ -0,0 +1,4 @@
+from code_quality_guard.cli import main
+
+if __name__ == "__main__":
+    main()

code_quality_guard/application/__init__.py

@@ -0,0 +1 @@
+"""Application orchestration for quality checks."""

code_quality_guard/application/service.py

@@ -0,0 +1,9 @@
+from __future__ import annotations
+
+from code_quality_guard.config.settings import Settings
+from code_quality_guard.runner import CommandResult
+from code_quality_guard.tools.registry import build_tools
+
+
+def run_quality_checks(settings: Settings) -> dict[str, CommandResult]:
+    return {tool.name: tool.run(settings) for tool in build_tools(settings.tools)}

code_quality_guard/cli.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import click
+
+from code_quality_guard.application.service import run_quality_checks
+from code_quality_guard.config.settings import Settings
+from code_quality_guard.reporter.console import render_console
+from code_quality_guard.reporter.json import render_json
+
+TOOL_NAMES = ["ruff", "ruff-format", "mypy"]
+
+
+@click.command()
+@click.argument("target", type=click.Path(path_type=Path, exists=True), default=Path.cwd())
+@click.option("--tool", "tools", multiple=True, type=click.Choice(TOOL_NAMES))
+@click.option("--fix", is_flag=True, help="Apply supported fixes.")
+@click.option("--check-only", is_flag=True, help="Check formatting without changing files.")
+@click.option("--output", type=click.Choice(["text", "json"]), default="text", show_default=True)
+@click.option(
+    "--tool-arg",
+    "tool_args",
+    nargs=2,
+    multiple=True,
+    metavar="TOOL ARG",
+    help="Pass an additional argument to a tool; repeat as needed.",
+)
+def main(
+    target: Path,
+    tools: tuple[str, ...],
+    fix: bool,
+    check_only: bool,
+    output: str,
+    tool_args: tuple[tuple[str, str], ...],
+) -> None:
+    """Run selected code quality tools against TARGET."""
+    selected_tools = tools or tuple(TOOL_NAMES)
+    args_by_tool: dict[str, tuple[str, ...]] = {}
+    for tool_name, argument in tool_args:
+        if tool_name not in selected_tools:
+            raise click.BadParameter(f"{tool_name!r} is not selected with --tool")
+        args_by_tool[tool_name] = (*args_by_tool.get(tool_name, ()), argument)
+    settings = Settings(
+        target=target.resolve(),
+        tools=selected_tools,
+        fix=fix,
+        check_only=check_only,
+        output=output,
+        tool_args=args_by_tool,
+    )
+    results = run_quality_checks(settings)
+    if settings.output == "json":
+        click.echo(render_json(results))
+    else:
+        render_console(results)
+    if not all(result.passed for result in results.values()):
+        raise click.exceptions.Exit(1)

code_quality_guard/config/__init__.py

@@ -0,0 +1,3 @@
+from .settings import Settings
+
+__all__ = ["Settings"]

code_quality_guard/config/settings.py

@@ -0,0 +1,15 @@
+from pathlib import Path
+from typing import Literal
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class Settings(BaseModel):
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    target: Path = Field(default_factory=Path.cwd)
+    tools: tuple[str, ...] = ("ruff", "mypy")
+    fix: bool = False
+    check_only: bool = False
+    output: Literal["text", "json"] = "text"
+    tool_args: dict[str, tuple[str, ...]] = Field(default_factory=dict)

code_quality_guard/reporter/__init__.py

@@ -0,0 +1 @@
+"""Human and machine-readable reporting."""

code_quality_guard/reporter/console.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+from rich.console import Console
+
+from code_quality_guard.runner import CommandResult
+
+
+def render_console(results: dict[str, CommandResult]) -> None:
+    console = Console()
+    for name, result in results.items():
+        status = "PASS" if result.passed else "FAIL"
+        color = "green" if result.passed else "red"
+        console.print(
+            f"[{color}][{status}][/{color}] {name} ({result.duration_seconds:.2f}s)"
+        )
+        diagnostics = "\n".join(
+            output.strip() for output in (result.stdout, result.stderr) if output.strip()
+        )
+        if diagnostics:
+            console.print(diagnostics, markup=False)

code_quality_guard/reporter/json.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+import json
+from dataclasses import asdict
+from typing import Any
+
+from code_quality_guard.runner import CommandResult
+
+
+def render_json(results: dict[str, CommandResult]) -> str:
+    payload: dict[str, Any] = {
+        "checks": {name: asdict(result) for name, result in results.items()},
+        "passed": all(result.passed for result in results.values()),
+    }
+    return json.dumps(payload, indent=2, sort_keys=True)

code_quality_guard/runner.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+import subprocess
+import time
+from dataclasses import dataclass
+from pathlib import Path
+
+
+@dataclass(frozen=True)
+class CommandResult:
+    command: list[str]
+    passed: bool
+    exit_code: int
+    stdout: str
+    stderr: str
+    duration_seconds: float
+
+
+class SubprocessRunner:
+    def run(self, command: list[str], cwd: Path | None = None) -> CommandResult:
+        started = time.perf_counter()
+        try:
+            completed = subprocess.run(
+                command, cwd=cwd, capture_output=True, text=True, check=False
+            )
+            stdout, stderr, exit_code = completed.stdout, completed.stderr, completed.returncode
+        except FileNotFoundError as error:
+            stdout, stderr, exit_code = (
+                "",
+                f"Command not found: {error.filename or command[0]}",
+                127,
+            )
+        return CommandResult(
+            command=command,
+            passed=exit_code == 0,
+            exit_code=exit_code,
+            stdout=stdout,
+            stderr=stderr,
+            duration_seconds=time.perf_counter() - started,
+        )

code_quality_guard/tools/__init__.py

@@ -0,0 +1 @@
+"""Adapters for external quality tools."""

code_quality_guard/tools/base.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+from typing import Protocol
+
+from code_quality_guard.config.settings import Settings
+from code_quality_guard.runner import CommandResult
+
+
+class Tool(Protocol):
+    name: str
+
+    def run(self, settings: Settings) -> CommandResult:
+        """Run the tool for the configured target."""

code_quality_guard/tools/command.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+import shutil
+import sys
+from pathlib import Path
+
+
+def resolve_executable(name: str) -> str:
+    environment_executable = Path(sys.executable).with_name(name)
+    if environment_executable.exists():
+        return str(environment_executable)
+    return shutil.which(name) or name

code_quality_guard/tools/mypy.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from code_quality_guard.config.settings import Settings
+from code_quality_guard.runner import CommandResult, SubprocessRunner
+from code_quality_guard.tools.command import resolve_executable
+
+
+class MypyTool:
+    name = "mypy"
+
+    def __init__(self, runner: SubprocessRunner | None = None) -> None:
+        self.runner = runner or SubprocessRunner()
+
+    def run(self, settings: Settings) -> CommandResult:
+        command = [resolve_executable("mypy"), str(settings.target)]
+        command.extend(settings.tool_args.get(self.name, ()))
+        cwd = settings.target if settings.target.is_dir() else settings.target.parent
+        return self.runner.run(command, cwd=cwd)

code_quality_guard/tools/registry.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+from collections.abc import Iterable
+
+from code_quality_guard.runner import SubprocessRunner
+from code_quality_guard.tools.base import Tool
+from code_quality_guard.tools.mypy import MypyTool
+from code_quality_guard.tools.ruff import RuffTool
+from code_quality_guard.tools.ruff_format import RuffFormatTool
+
+TOOL_TYPES: dict[str, type[Tool]] = {
+    "ruff": RuffTool,
+    "ruff-format": RuffFormatTool,
+    "mypy": MypyTool,
+}
+
+
+def build_tools(tool_names: Iterable[str], runner: SubprocessRunner | None = None) -> list[Tool]:
+    shared_runner = runner or SubprocessRunner()
+    return [TOOL_TYPES[name](shared_runner) for name in tool_names]

code_quality_guard/tools/ruff.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+from code_quality_guard.config.settings import Settings
+from code_quality_guard.runner import CommandResult, SubprocessRunner
+from code_quality_guard.tools.command import resolve_executable
+
+
+class RuffTool:
+    name = "ruff"
+
+    def __init__(self, runner: SubprocessRunner | None = None) -> None:
+        self.runner = runner or SubprocessRunner()
+
+    def run(self, settings: Settings) -> CommandResult:
+        command = [resolve_executable("ruff"), "check", str(settings.target)]
+        if settings.fix:
+            command.append("--fix")
+        command.extend(settings.tool_args.get(self.name, ()))
+        cwd = settings.target if settings.target.is_dir() else settings.target.parent
+        return self.runner.run(command, cwd=cwd)

code_quality_guard/tools/ruff_format.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+from code_quality_guard.config.settings import Settings
+from code_quality_guard.runner import CommandResult, SubprocessRunner
+from code_quality_guard.tools.command import resolve_executable
+
+
+class RuffFormatTool:
+    name = "ruff-format"
+
+    def __init__(self, runner: SubprocessRunner | None = None) -> None:
+        self.runner = runner or SubprocessRunner()
+
+    def run(self, settings: Settings) -> CommandResult:
+        command = [resolve_executable("ruff"), "format", str(settings.target)]
+        if not settings.fix or settings.check_only:
+            command.append("--check")
+        command.extend(settings.tool_args.get(self.name, ()))
+        cwd = settings.target if settings.target.is_dir() else settings.target.parent
+        return self.runner.run(command, cwd=cwd)

py_code_quality_guard-0.1.0.dist-info/METADATA

@@ -0,0 +1,145 @@
+Metadata-Version: 2.5
+Name: py-code-quality-guard
+Version: 0.1.0
+Summary: Automated Code Quality Guard for Python
+Requires-Python: >=3.12
+Requires-Dist: click>=8.1
+Requires-Dist: mypy>=1.11
+Requires-Dist: pydantic>=2.8
+Requires-Dist: rich>=13.7
+Requires-Dist: ruff>=0.6
+Description-Content-Type: text/markdown
+
+# Code Quality Guard
+
+[![CI](https://github.com/karma369-labs/code-quality-guard/actions/workflows/ci.yml/badge.svg)](https://github.com/karma369-labs/code-quality-guard/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/py-code-quality-guard)](https://pypi.org/project/py-code-quality-guard/)
+[![Python](https://img.shields.io/badge/python-3.12%2B-3776AB?logo=python&logoColor=white)](https://www.python.org/)
+[![Ruff](https://img.shields.io/badge/linter-Ruff-D7FF64?logo=ruff&logoColor=black)](https://docs.astral.sh/ruff/)
+[![Mypy](https://img.shields.io/badge/type%20checker-Mypy-4B8BBE?logo=mypy&logoColor=white)](https://mypy-lang.org/)
+
+`py-code-quality-guard` is a CI-friendly command-line quality gate for Python
+projects. It runs Ruff linting, Ruff formatting, and Mypy through one
+consistent interface, with human-readable or JSON output for local workflows
+and automation.
+
+## Features
+
+- Run Ruff, Ruff format, and Mypy independently or together.
+- Check a project directory or a single file.
+- Apply Ruff fixes when supported.
+- Forward additional arguments to each selected tool.
+- Emit text for developers or JSON for scripts and CI integrations.
+- Return a non-zero exit code when any selected check fails.
+
+## Requirements
+
+- Python 3.12 or newer
+- Ruff and Mypy are installed automatically with the package
+
+## Installation
+
+Install the latest release from PyPI in an active virtual environment:
+
+```bash
+python -m pip install py-code-quality-guard
+```
+
+For local development with `uv`:
+
+```bash
+uv sync --dev
+```
+
+## Pre-commit Hook
+
+Add `py-code-quality-guard` to a project-level `.pre-commit-config.yaml`:
+
+```yaml
+repos:
+	- repo: https://github.com/karma369-labs/code-quality-guard
+		rev: v0.1.0
+		hooks:
+			- id: cqg
+```
+
+Install the hook and run it against the repository:
+
+```bash
+python -m pip install pre-commit
+pre-commit install
+pre-commit run --all-files
+```
+
+The `cqg` hook runs Ruff linting, Ruff formatting checks, and Mypy over the
+project. To use a newer release, update `rev` to the corresponding package
+release tag.
+
+## Usage
+
+Run all checks against the current directory:
+
+```bash
+pyqguard .
+```
+
+Run selected tools:
+
+```bash
+pyqguard --tool ruff --tool mypy src/
+```
+
+Checks report the tools' diagnostics without changing files by default:
+
+```bash
+pyqguard --tool ruff-format .
+```
+
+Apply supported fixes:
+
+```bash
+pyqguard --tool ruff --tool ruff-format --fix .
+```
+
+Produce machine-readable output:
+
+```bash
+pyqguard --output json .
+```
+
+Pass an additional argument to a selected tool. Repeat `--tool-arg` as
+needed:
+
+```bash
+pyqguard \
+	--tool ruff \
+	--tool-arg ruff --select \
+	--tool-arg ruff E,F \
+	.
+```
+
+Run `pyqguard --help` for the complete option reference.
+
+## Development
+
+Install the development dependencies and run the test suite:
+
+```bash
+uv sync --dev
+uv run pytest
+```
+
+The repository uses pre-commit for linting, formatting, type checking, and
+other repository checks:
+
+```bash
+uv run pre-commit install
+uv run pre-commit run --all-files
+```
+
+Pull requests targeting `main` run the same pre-commit checks in GitHub Actions.
+
+
+## License
+
+License information has not yet been published for this repository.

py_code_quality_guard-0.1.0.dist-info/RECORD

@@ -0,0 +1,22 @@
+code_quality_guard/__init__.py,sha256=FHnejSyA5evlvUzI5BZ_nGclmTRD0TYGE_LLQon0i0o,74
+code_quality_guard/__main__.py,sha256=z6avlHkTjs-a1WryEOKKIm89j5UpRLr1-vladd4NVng,79
+code_quality_guard/cli.py,sha256=RP-WzxVW0rcvEdN95FTn8JlMI9MiaCE9prk_DcoMYmk,2021
+code_quality_guard/runner.py,sha256=asrXo8C3fxqJI51IjcTK9AUjoaAWwUdef5R-Yuho5eQ,1139
+code_quality_guard/application/__init__.py,sha256=MOpct-O3F3gJEWUV338kWgT_xk3TXaMFqRuJqil7lLM,52
+code_quality_guard/application/service.py,sha256=Ovw5hRoQCEtic-WascA_6npqW9o6mdTNETgWp6ijQ9k,359
+code_quality_guard/config/__init__.py,sha256=hTPvRTo00qLky4IQytXV_BdOEiPmWdFiDecCKr4tf-o,55
+code_quality_guard/config/settings.py,sha256=qfizoCxRK9pYgX8szbQi3BFz_6ca2fB9DP8U6bsUhIg,458
+code_quality_guard/reporter/__init__.py,sha256=XuylpgedmzS1SWzq2wT5eEqCZJ4sgOmCrSg7XoQTLAw,44
+code_quality_guard/reporter/console.py,sha256=JTfQ5c4JifgclsFDs3923JDd4kgorUxkKNk_PU-yolU,685
+code_quality_guard/reporter/json.py,sha256=xjwNbhaQFTClud7eBEoYaU4Yzk-86CP9HBaZtR5rOX8,458
+code_quality_guard/tools/__init__.py,sha256=oRrDTXhlOPv6UcBxlwRCMx-DXWUTrpq4kuSNxqWGH4s,43
+code_quality_guard/tools/base.py,sha256=0ULTPaIhlLlWCzLiCC0Sl0Huh3y5xBeC75J2sTF9Bgo,322
+code_quality_guard/tools/command.py,sha256=m2CUZQhtmjZv9YzPhcAH2jvocZVgm5bWumzcIWdhvFA,317
+code_quality_guard/tools/mypy.py,sha256=2q5IKHlc1HKWDTZwzwh6MzmxDlioyQ9GnHGDxn61ps4,709
+code_quality_guard/tools/registry.py,sha256=efx5TRweS3nVeAHF7x1w_fYrpe1QBSBogbsHDonOT18,679
+code_quality_guard/tools/ruff.py,sha256=DcXm3cgnX9lHKzz4kQfPxFJPvh-RePBRa6Tk-IpTHM4,779
+code_quality_guard/tools/ruff_format.py,sha256=iRJEAK8TgosFIC40J-YdHoASZ0-EX7V1ZJ8WWkf_XBw,822
+py_code_quality_guard-0.1.0.dist-info/METADATA,sha256=4kI6u9JL4D35UJGbIAXfoykB6Ljf9x_df84wwOeDby8,3494
+py_code_quality_guard-0.1.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+py_code_quality_guard-0.1.0.dist-info/entry_points.txt,sha256=6gEyXFusP1d8acz_PL4MAHrE3EMF3vnWFnVzycVBOUE,57
+py_code_quality_guard-0.1.0.dist-info/RECORD,,

py_code_quality_guard-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

py_code_quality_guard-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+pyqguard = code_quality_guard.cli:main