commit-check-mcp 0.1.1.post1.dev1__py3-none-any.whl

commit_check_mcp/__init__.py

@@ -0,0 +1,6 @@
+"""commit-check-mcp package."""
+
+from importlib.metadata import version
+
+__all__ = ["__version__"]
+__version__ = version("commit-check-mcp")

commit_check_mcp/server.py

@@ -0,0 +1,504 @@
+"""MCP server for commit-check validations."""
+
+from __future__ import annotations
+
+from contextlib import contextmanager
+from contextlib import redirect_stderr, redirect_stdout
+from importlib.metadata import version
+import io
+from pathlib import Path
+import os
+from typing import Any
+
+from commit_check import __version__ as commit_check_version
+from commit_check.config_merger import deep_merge, get_default_config, load_toml_config
+from commit_check.engine import ValidationContext, ValidationEngine, ValidationResult
+from commit_check.rule_builder import RuleBuilder, ValidationRule
+from commit_check.rules_catalog import BRANCH_RULES, COMMIT_RULES
+from mcp.server.fastmcp import FastMCP
+
+from . import __version__
+
+mcp = FastMCP(
+    "commit-check-mcp",
+    instructions=(
+        "Use these tools to validate commit messages, branch names, and author metadata "
+        "with commit-check."
+    ),
+)
+
+
+def _normalize_config(config: dict[str, Any] | None) -> dict[str, Any] | None:
+    """Ensure tool config input is JSON-object-like."""
+    if config is None:
+        return None
+    if not isinstance(config, dict):
+        raise ValueError("config must be an object/dictionary when provided")
+    return config
+
+
+def _normalize_repo_path(repo_path: str | None) -> Path | None:
+    """Normalize and validate an optional repository path."""
+    if repo_path is None:
+        return None
+    if not isinstance(repo_path, str):
+        raise ValueError("repo_path must be a string when provided")
+    normalized = repo_path.strip()
+    if not normalized:
+        raise ValueError("repo_path cannot be empty when provided")
+
+    path = Path(normalized).expanduser().resolve()
+    if not path.exists():
+        raise ValueError(f"repo_path does not exist: {path}")
+    if not path.is_dir():
+        raise ValueError(f"repo_path must be a directory: {path}")
+    return path
+
+
+def _normalize_config_path(config_path: str | None, repo_path: Path | None) -> str | None:
+    """Normalize and validate an optional config path."""
+    if config_path is None:
+        return None
+    if not isinstance(config_path, str):
+        raise ValueError("config_path must be a string when provided")
+    normalized = config_path.strip()
+    if not normalized:
+        raise ValueError("config_path cannot be empty when provided")
+
+    path = Path(normalized).expanduser()
+    if not path.is_absolute() and repo_path is not None:
+        path = repo_path / path
+
+    resolved = path.resolve()
+    if not resolved.exists():
+        raise ValueError(f"config_path does not exist: {resolved}")
+    if not resolved.is_file():
+        raise ValueError(f"config_path must be a file: {resolved}")
+    return str(resolved)
+
+
+@contextmanager
+def _working_directory(repo_path: Path | None):
+    """Temporarily switch working directory for repo-relative config and git checks."""
+    if repo_path is None:
+        yield
+        return
+
+    original_cwd = Path.cwd()
+    os.chdir(repo_path)
+    try:
+        yield
+    finally:
+        os.chdir(original_cwd)
+
+
+def _merge_config(
+    config: dict[str, Any] | None,
+    *,
+    repo_path: Path | None = None,
+    config_path: str | None = None,
+) -> dict[str, Any]:
+    """Merge repository config and user config on top of commit-check defaults."""
+    merged = get_default_config()
+    with _working_directory(repo_path):
+        loaded_config = load_toml_config(config_path or "")
+    if loaded_config:
+        deep_merge(merged, loaded_config)
+    if config:
+        deep_merge(merged, config)
+    return merged
+
+
+def _run_checks(
+    check_names: list[str],
+    context: ValidationContext,
+    config: dict[str, Any],
+) -> dict[str, Any]:
+    """Run commit-check rules and always return structured per-check results."""
+    rules = RuleBuilder(config).build_all_rules()
+    filtered: list[ValidationRule] = [r for r in rules if r.check in check_names]
+
+    checks: list[dict[str, Any]] = []
+    for rule in filtered:
+        with io.StringIO() as _out, io.StringIO() as _err:
+            with redirect_stdout(_out), redirect_stderr(_err):
+                status = ValidationEngine([rule]).validate_all(context)
+        passed = status == ValidationResult.PASS
+        checks.append(
+            {
+                "check": rule.check,
+                "status": "pass" if passed else "fail",
+                "value": context.stdin_text or "",
+                "error": "" if passed else (rule.error or ""),
+                "suggest": "" if passed else (rule.suggest or ""),
+            }
+        )
+
+    overall = "fail" if any(c["status"] == "fail" for c in checks) else "pass"
+    return {"status": overall, "checks": checks}
+
+
+def _validate_message(
+    message: str,
+    *,
+    config: dict[str, Any] | None = None,
+    repo_path: Path | None = None,
+    config_path: str | None = None,
+) -> dict[str, Any]:
+    """Validate message using commit-check engine internals."""
+    cfg = _merge_config(config, repo_path=repo_path, config_path=config_path)
+    with _working_directory(repo_path):
+        return _run_checks(
+            [
+                "message",
+                "subject_imperative",
+                "subject_max_length",
+                "subject_min_length",
+                "subject_capitalized",
+                "require_signed_off_by",
+                "require_body",
+                "allow_merge_commits",
+                "allow_revert_commits",
+                "allow_empty_commits",
+                "allow_fixup_commits",
+                "allow_wip_commits",
+            ],
+            ValidationContext(stdin_text=message, config=cfg),
+            cfg,
+        )
+
+
+def _validate_branch(
+    branch: str | None = None,
+    *,
+    config: dict[str, Any] | None = None,
+    repo_path: Path | None = None,
+    config_path: str | None = None,
+) -> dict[str, Any]:
+    """Validate branch name using commit-check engine internals."""
+    cfg = _merge_config(config, repo_path=repo_path, config_path=config_path)
+    with _working_directory(repo_path):
+        return _run_checks(
+            ["branch", "merge_base"],
+            ValidationContext(stdin_text=branch, config=cfg),
+            cfg,
+        )
+
+
+def _validate_author(
+    name: str | None = None,
+    email: str | None = None,
+    *,
+    config: dict[str, Any] | None = None,
+    repo_path: Path | None = None,
+    config_path: str | None = None,
+) -> dict[str, Any]:
+    """Validate author info using commit-check engine internals."""
+    cfg = _merge_config(config, repo_path=repo_path, config_path=config_path)
+
+    with _working_directory(repo_path):
+        if name is not None and email is not None:
+            name_result = _run_checks(
+                ["author_name"],
+                ValidationContext(stdin_text=name, config=cfg),
+                cfg,
+            )
+            email_result = _run_checks(
+                ["author_email"],
+                ValidationContext(stdin_text=email, config=cfg),
+                cfg,
+            )
+            checks = name_result["checks"] + email_result["checks"]
+            return {
+                "status": "fail" if any(c["status"] == "fail" for c in checks) else "pass",
+                "checks": checks,
+            }
+
+        check_names: list[str] = []
+        stdin = None
+        if name is not None:
+            check_names.append("author_name")
+            stdin = name
+        if email is not None:
+            check_names.append("author_email")
+            stdin = email
+        if not check_names:
+            check_names = ["author_name", "author_email"]
+
+        return _run_checks(check_names, ValidationContext(stdin_text=stdin, config=cfg), cfg)
+
+
+def _validate_all(
+    message: str | None = None,
+    branch: str | None = None,
+    author_name: str | None = None,
+    author_email: str | None = None,
+    *,
+    config: dict[str, Any] | None = None,
+    repo_path: Path | None = None,
+    config_path: str | None = None,
+) -> dict[str, Any]:
+    """Validate multiple commit-check contexts and combine outcomes."""
+    cfg = _merge_config(config, repo_path=repo_path, config_path=config_path)
+    checks: list[dict[str, Any]] = []
+
+    with _working_directory(repo_path):
+        if message is not None:
+            checks.extend(
+                _run_checks(
+                    [
+                        "message",
+                        "subject_imperative",
+                        "subject_max_length",
+                        "subject_min_length",
+                        "subject_capitalized",
+                        "require_signed_off_by",
+                        "require_body",
+                        "allow_merge_commits",
+                        "allow_revert_commits",
+                        "allow_empty_commits",
+                        "allow_fixup_commits",
+                        "allow_wip_commits",
+                    ],
+                    ValidationContext(stdin_text=message, config=cfg),
+                    cfg,
+                )["checks"]
+            )
+        if branch is not None:
+            checks.extend(
+                _run_checks(
+                    ["branch", "merge_base"],
+                    ValidationContext(stdin_text=branch, config=cfg),
+                    cfg,
+                )["checks"]
+            )
+        if author_name is not None or author_email is not None:
+            if author_name is not None:
+                checks.extend(
+                    _run_checks(
+                        ["author_name"],
+                        ValidationContext(stdin_text=author_name, config=cfg),
+                        cfg,
+                    )["checks"]
+                )
+            if author_email is not None:
+                checks.extend(
+                    _run_checks(
+                        ["author_email"],
+                        ValidationContext(stdin_text=author_email, config=cfg),
+                        cfg,
+                    )["checks"]
+                )
+
+    return {
+        "status": "fail" if any(c["status"] == "fail" for c in checks) else "pass",
+        "checks": checks,
+    }
+
+
+@mcp.tool()
+def server_health() -> dict[str, str]:
+    """Return server and dependency versions."""
+    return {
+        "server": "commit-check-mcp",
+        "server_version": __version__,
+        "commit_check_version": commit_check_version,
+        "mcp_sdk_version": version("mcp"),
+    }
+
+
+@mcp.tool()
+def validate_commit_message(
+    message: str,
+    config: dict[str, Any] | None = None,
+    repo_path: str | None = None,
+    config_path: str | None = None,
+) -> dict[str, Any]:
+    """Validate a commit message against commit-check rules."""
+    if not isinstance(message, str) or not message.strip():
+        raise ValueError("message must be a non-empty string")
+    normalized_repo_path = _normalize_repo_path(repo_path)
+    return _validate_message(
+        message.strip(),
+        config=_normalize_config(config),
+        repo_path=normalized_repo_path,
+        config_path=_normalize_config_path(config_path, normalized_repo_path),
+    )
+
+
+@mcp.tool()
+def validate_branch_name(
+    branch: str | None = None,
+    config: dict[str, Any] | None = None,
+    repo_path: str | None = None,
+    config_path: str | None = None,
+) -> dict[str, Any]:
+    """Validate branch naming conventions with commit-check."""
+    normalized_branch = branch.strip() if isinstance(branch, str) else None
+    if isinstance(branch, str) and not normalized_branch:
+        raise ValueError("branch cannot be empty when provided")
+    normalized_repo_path = _normalize_repo_path(repo_path)
+    return _validate_branch(
+        normalized_branch,
+        config=_normalize_config(config),
+        repo_path=normalized_repo_path,
+        config_path=_normalize_config_path(config_path, normalized_repo_path),
+    )
+
+
+@mcp.tool()
+def validate_author_info(
+    author_name: str | None = None,
+    author_email: str | None = None,
+    config: dict[str, Any] | None = None,
+    repo_path: str | None = None,
+    config_path: str | None = None,
+) -> dict[str, Any]:
+    """Validate commit author name and/or email with commit-check."""
+    normalized_name = author_name.strip() if isinstance(author_name, str) else None
+    normalized_email = author_email.strip() if isinstance(author_email, str) else None
+
+    if isinstance(author_name, str) and not normalized_name:
+        raise ValueError("author_name cannot be empty when provided")
+    if isinstance(author_email, str) and not normalized_email:
+        raise ValueError("author_email cannot be empty when provided")
+    normalized_repo_path = _normalize_repo_path(repo_path)
+
+    return _validate_author(
+        normalized_name,
+        normalized_email,
+        config=_normalize_config(config),
+        repo_path=normalized_repo_path,
+        config_path=_normalize_config_path(config_path, normalized_repo_path),
+    )
+
+
+@mcp.tool()
+def validate_commit_context(
+    message: str | None = None,
+    branch: str | None = None,
+    author_name: str | None = None,
+    author_email: str | None = None,
+    config: dict[str, Any] | None = None,
+    repo_path: str | None = None,
+    config_path: str | None = None,
+) -> dict[str, Any]:
+    """Run combined commit-check validations in one call."""
+    normalized_message = message.strip() if isinstance(message, str) else None
+    normalized_branch = branch.strip() if isinstance(branch, str) else None
+    normalized_name = author_name.strip() if isinstance(author_name, str) else None
+    normalized_email = author_email.strip() if isinstance(author_email, str) else None
+
+    if isinstance(message, str) and not normalized_message:
+        raise ValueError("message cannot be empty when provided")
+    if isinstance(branch, str) and not normalized_branch:
+        raise ValueError("branch cannot be empty when provided")
+    if isinstance(author_name, str) and not normalized_name:
+        raise ValueError("author_name cannot be empty when provided")
+    if isinstance(author_email, str) and not normalized_email:
+        raise ValueError("author_email cannot be empty when provided")
+
+    if not any([normalized_message, normalized_branch, normalized_name, normalized_email]):
+        raise ValueError(
+            "At least one of message, branch, author_name, or author_email must be provided"
+        )
+    normalized_repo_path = _normalize_repo_path(repo_path)
+
+    return _validate_all(
+        message=normalized_message,
+        branch=normalized_branch,
+        author_name=normalized_name,
+        author_email=normalized_email,
+        config=_normalize_config(config),
+        repo_path=normalized_repo_path,
+        config_path=_normalize_config_path(config_path, normalized_repo_path),
+    )
+
+
+@mcp.tool()
+def validate_repository_state(
+    repo_path: str | None = None,
+    config: dict[str, Any] | None = None,
+    config_path: str | None = None,
+    include_message: bool = True,
+    include_branch: bool = True,
+    include_author: bool = True,
+) -> dict[str, Any]:
+    """Validate the latest commit, current branch, and git author state of a repository."""
+    if not any([include_message, include_branch, include_author]):
+        raise ValueError("At least one validation target must be enabled")
+
+    normalized_repo_path = _normalize_repo_path(repo_path)
+    normalized_config = _normalize_config(config)
+    normalized_config_path = _normalize_config_path(config_path, normalized_repo_path)
+
+    checks: list[dict[str, Any]] = []
+    if include_message:
+        checks.extend(
+            _validate_message(
+                "",
+                config=normalized_config,
+                repo_path=normalized_repo_path,
+                config_path=normalized_config_path,
+            )["checks"]
+        )
+    if include_branch:
+        checks.extend(
+            _validate_branch(
+                None,
+                config=normalized_config,
+                repo_path=normalized_repo_path,
+                config_path=normalized_config_path,
+            )["checks"]
+        )
+    if include_author:
+        checks.extend(
+            _validate_author(
+                None,
+                None,
+                config=normalized_config,
+                repo_path=normalized_repo_path,
+                config_path=normalized_config_path,
+            )["checks"]
+        )
+
+    return {
+        "status": "fail" if any(c["status"] == "fail" for c in checks) else "pass",
+        "checks": checks,
+    }
+
+
+@mcp.tool()
+def describe_validation_rules(
+    config: dict[str, Any] | None = None,
+    repo_path: str | None = None,
+    config_path: str | None = None,
+) -> dict[str, Any]:
+    """Return enabled commit-check rules after merging defaults, repo config, and overrides."""
+    normalized_repo_path = _normalize_repo_path(repo_path)
+    normalized_config = _normalize_config(config)
+    normalized_config_path = _normalize_config_path(config_path, normalized_repo_path)
+    merged_config = _merge_config(
+        normalized_config,
+        repo_path=normalized_repo_path,
+        config_path=normalized_config_path,
+    )
+    rules = [rule.to_dict() for rule in RuleBuilder(merged_config).build_all_rules()]
+
+    return {
+        "commit_check_version": commit_check_version,
+        "config": merged_config,
+        "supported_checks": list(
+            dict.fromkeys(entry.check for entry in COMMIT_RULES + BRANCH_RULES)
+        ),
+        "enabled_rules": rules,
+    }
+
+
+def main() -> None:
+    """Run commit-check MCP server via stdio transport."""
+    mcp.run(transport="stdio")
+
+
+if __name__ == "__main__":  # pragma: no cover
+    main()

commit_check_mcp-0.1.1.post1.dev1.dist-info/METADATA

@@ -0,0 +1,86 @@
+Metadata-Version: 2.4
+Name: commit-check-mcp
+Version: 0.1.1.post1.dev1
+Summary: MCP server exposing commit-check validation tools
+Author: commit-check
+License: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: commit-check<3,>=2.5.0
+Requires-Dist: mcp<2,>=1.27.0
+Provides-Extra: dev
+Requires-Dist: pytest<10,>=9.0.0; extra == "dev"
+Dynamic: license-file
+
+# commit-check-mcp
+
+Model Context Protocol (MCP) server for [commit-check](https://github.com/commit-check/commit-check).
+
+## Features
+
+This MCP server exposes commit-check validations as MCP tools:
+
+- `server_health` — returns server/sdk versions
+- `validate_commit_message` — validates a commit message
+- `validate_branch_name` — validates a branch name or the current repo branch
+- `validate_author_info` — validates author name/email or the repo's git author config
+- `validate_commit_context` — runs combined checks in one call
+- `validate_repository_state` — validates latest commit, current branch, and author state for a repo
+- `describe_validation_rules` — returns the effective config and enabled rules after merging defaults and repo config
+
+All validation tools return the same structured commit-check result shape:
+
+```json
+{
+  "status": "pass|fail",
+  "checks": [
+    {
+      "check": "message",
+      "status": "pass|fail",
+      "value": "...",
+      "error": "...",
+      "suggest": "..."
+    }
+  ]
+}
+```
+
+## Install
+
+```bash
+pip install -e .
+```
+
+## Run
+
+```bash
+commit-check-mcp
+```
+
+The server runs over stdio transport (recommended MCP default for local tool integrations).
+
+## Repository-Aware Validation
+
+`commit-check` is most useful when it runs against a real git repository and its `cchk.toml` or `commit-check.toml` file. This MCP server now supports that directly:
+
+- `repo_path` — run git-based validations against a specific repository
+- `config_path` — point to an explicit TOML config file; relative paths are resolved from `repo_path`
+- `config` — apply ad-hoc overrides on top of defaults and repo config
+
+Typical patterns:
+
+- Validate an explicit message with a repository's rules
+- Validate the current repository state without passing message/branch/author values manually
+- Inspect which rules are actually enabled after config merging
+
+Example payload for a repository-wide validation:
+
+```json
+{
+  "repo_path": "/path/to/repo",
+  "include_message": true,
+  "include_branch": true,
+  "include_author": true
+}
+```

commit_check_mcp-0.1.1.post1.dev1.dist-info/RECORD

@@ -0,0 +1,8 @@
+commit_check_mcp/__init__.py,sha256=0qlKOLxQwzq4RmQlxbdAO2UT7y0zKqS2RQq-PQs7jkM,141
+commit_check_mcp/server.py,sha256=aZfgzLQp_pWKYgMm49IZRBCOuQiMiscMU6ltfr5OJIo,17505
+commit_check_mcp-0.1.1.post1.dev1.dist-info/licenses/LICENSE,sha256=XMRJzGhsjuBcVso4JnpcvzaDBl7N1TR4WU_Y6E8f6Wk,1069
+commit_check_mcp-0.1.1.post1.dev1.dist-info/METADATA,sha256=W_qoI2-LwxjVUACHNOZTqOVaGjxD0mgzFiMQG_OvuaQ,2483
+commit_check_mcp-0.1.1.post1.dev1.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+commit_check_mcp-0.1.1.post1.dev1.dist-info/entry_points.txt,sha256=Aj84jmw43ZbHhkLA2W_tFQSMj0cn_xw8GAlL-44trH4,66
+commit_check_mcp-0.1.1.post1.dev1.dist-info/top_level.txt,sha256=VPx0wL4_vLMrJSZou2krNUhaa8NAjlqbgJKjN2co4ic,17
+commit_check_mcp-0.1.1.post1.dev1.dist-info/RECORD,,

commit_check_mcp-0.1.1.post1.dev1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

commit_check_mcp-0.1.1.post1.dev1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+commit-check-mcp = commit_check_mcp.server:main

commit_check_mcp-0.1.1.post1.dev1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Commit Check
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

commit_check_mcp-0.1.1.post1.dev1.dist-info/top_level.txt

@@ -0,0 +1 @@
+commit_check_mcp