moai-adk 0.8.0__py3-none-any.whl → 1.1.0__py3-none-any.whl

moai_adk/templates/.claude/hooks/moai/post_tool__coverage_guard.py

@@ -0,0 +1,325 @@
+#!/usr/bin/env python3
+"""PostToolUse Hook: Universal Test Coverage Guard (Python, TypeScript, JavaScript)
+
+Checks test coverage after code writes for Python, TypeScript, and JavaScript.
+Supports multiple testing frameworks and coverage tools.
+
+Exit Codes:
+- 0: Success (coverage checked, results reported)
+- 2: Coverage below target (get user attention)
+"""
+
+from __future__ import annotations
+
+import json
+import subprocess
+import sys
+from pathlib import Path
+from typing import Any
+
+# Setup import path for shared modules
+HOOKS_DIR = Path(__file__).parent
+LIB_DIR = HOOKS_DIR / "lib"
+if str(LIB_DIR) not in sys.path:
+    sys.path.insert(0, str(LIB_DIR))
+
+try:
+    from language_detector import (
+        LANGUAGE_CONFIGS,
+        detect_language,
+        get_coverage_target,
+        get_test_file_path,
+    )
+except ImportError:
+    # Fallback implementations
+    LANGUAGE_CONFIGS = {
+        "Python": {
+            "extensions": [".py"],
+            "test_command": "uv run pytest -q tests/",
+            "coverage_command": (
+                "uv run coverage run --branch -m pytest -q tests/ && uv run coverage report --format=json"
+            ),
+        },
+        "TypeScript": {
+            "extensions": [".ts", ".tsx"],
+            "test_command": "npm test -- --run",
+            "coverage_command": (
+                "npm run test:coverage -- --reporter=json 2>/dev/null || "
+                "npm test -- --coverage --coverageReporters=json-summary"
+            ),
+        },
+        "JavaScript": {
+            "extensions": [".js", ".jsx"],
+            "test_command": "npm test -- --run",
+            "coverage_command": "npm run test:coverage -- --coverageReporters=json-summary",
+        },
+    }
+
+    def detect_language(file_path: Path) -> str | None:
+        ext = file_path.suffix.lower()
+        for lang, config in LANGUAGE_CONFIGS.items():
+            if ext in config.get("extensions", []):
+                return lang
+        return None
+
+    def get_test_file_path(_source_file: Path) -> Path | None:
+        return None
+
+    def get_coverage_target() -> int:
+        return 100
+
+
+class CoverageChecker:
+    """Coverage checker for multiple languages."""
+
+    def __init__(self, source_file: Path):
+        self.source_file = source_file
+        self.language = detect_language(source_file)
+        self.config = LANGUAGE_CONFIGS.get(self.language, {}) if self.language else {}
+
+    def check_coverage(self) -> dict[str, Any]:
+        """Run language-specific coverage check.
+
+        Returns:
+            Dictionary with coverage results
+        """
+        if not self.language:
+            return {"error": "Unsupported language", "skipped": True}
+
+        checkers = {
+            "Python": self._check_python_coverage,
+            "TypeScript": self._check_typescript_coverage,
+            "JavaScript": self._check_javascript_coverage,
+        }
+
+        checker = checkers.get(self.language)
+        if checker:
+            return checker()
+
+        return {"error": f"No coverage checker for {self.language}", "skipped": True}
+
+    def _check_python_coverage(self) -> dict[str, Any]:
+        """Check Python test coverage using coverage.py."""
+        try:
+            # Run pytest with coverage
+            subprocess.run(
+                ["uv", "run", "coverage", "run", "--branch", "-m", "pytest", "-q", "tests/"],
+                capture_output=True,
+                timeout=60,
+                check=False,
+            )
+
+            # Get JSON report
+            result = subprocess.run(
+                ["uv", "run", "coverage", "report", "--format=json"],
+                capture_output=True,
+                timeout=30,
+                text=True,
+            )
+
+            if result.returncode == 0:
+                data = json.loads(result.stdout)
+                files = data.get("files", [])
+
+                # Find coverage for this specific file
+                source_name = self.source_file.name
+                for f in files:
+                    if source_name in f.get("file", ""):
+                        summary = f.get("summary", {})
+                        return {
+                            "percent_covered": summary.get("percent_covered", 0),
+                            "tool": "coverage.py",
+                            "lines_covered": summary.get("covered_lines", 0),
+                            "lines_missing": summary.get("missing_lines", 0),
+                        }
+
+                # No specific file coverage, return total
+                totals = data.get("totals", {})
+                return {
+                    "percent_covered": totals.get("percent_covered", 0),
+                    "tool": "coverage.py",
+                }
+
+            return {"percent_covered": 0, "tool": "coverage.py"}
+        except FileNotFoundError:
+            return {"error": "uv or coverage.py not found", "skipped": True}
+        except subprocess.TimeoutExpired:
+            return {"error": "Coverage check timed out", "skipped": True}
+        except Exception as e:
+            return {"error": str(e), "skipped": True}
+
+    def _check_typescript_coverage(self) -> dict[str, Any]:
+        """Check TypeScript/JavaScript coverage using vitest or jest."""
+        try:
+            # Check package.json for test script
+            package_json = Path("package.json")
+            if not package_json.exists():
+                return {"error": "package.json not found", "skipped": True}
+
+            # Try vitest first (modern, faster)
+            result = subprocess.run(
+                ["npm", "run", "test:coverage", "--", "--reporter=json-summary", "--reporter=json"],
+                capture_output=True,
+                timeout=90,
+                text=True,
+            )
+
+            if result.returncode == 0:
+                # Parse vitest coverage
+                return self._parse_coverage_json(result.stdout, "vitest")
+
+            # Fallback to jest
+            result = subprocess.run(
+                ["npm", "test", "--", "--coverage", "--coverageReporters=json-summary"],
+                capture_output=True,
+                timeout=90,
+                text=True,
+            )
+
+            if result.returncode == 0:
+                return self._parse_coverage_json(result.stdout, "jest")
+
+            return {"percent_covered": 0, "tool": "vitest/jest", "skipped": True}
+
+        except FileNotFoundError:
+            return {"error": "npm not found", "skipped": True}
+        except subprocess.TimeoutExpired:
+            return {"error": "Coverage check timed out", "skipped": True}
+        except Exception as e:
+            return {"error": str(e), "skipped": True}
+
+    def _check_javascript_coverage(self) -> dict[str, Any]:
+        """JavaScript uses same tools as TypeScript."""
+        return self._check_typescript_coverage()
+
+    def _parse_coverage_json(self, output: str, tool: str) -> dict[str, Any]:
+        """Parse coverage JSON output from vitest or jest."""
+        try:
+            data = json.loads(output)
+
+            # Vitest format
+            if "total" in data:
+                total = data.get("total", {})
+                lines = total.get("lines", {})
+                return {
+                    "percent_covered": lines.get("pct", 0),
+                    "tool": tool,
+                }
+
+            # Jest format (JSON-summary)
+            if "total" in data:
+                total = data.get("total", {})
+                lines = total.get("lines", {})
+                return {
+                    "percent_covered": lines.get("pct", 0) * 100 if lines.get("pct") <= 1 else lines.get("pct", 0),
+                    "tool": tool,
+                }
+
+            return {"percent_covered": 0, "tool": tool}
+
+        except json.JSONDecodeError:
+            # Try to extract percentage from text
+            import re
+
+            match = re.search(r"Lines\s*:\s*([\d.]+)%", output)
+            if match:
+                return {"percent_covered": float(match.group(1)), "tool": tool}
+            return {"percent_covered": 0, "tool": tool}
+
+
+def main():
+    """Main hook logic."""
+    # Read hook input
+    try:
+        input_data = json.loads(sys.stdin.read())
+    except json.JSONDecodeError:
+        print(json.dumps({}))
+        sys.exit(0)
+
+    tool_name = input_data.get("tool_name", "")
+    tool_input = input_data.get("tool_input", {})
+
+    # Only check Write operations
+    if tool_name != "Write":
+        print(json.dumps({}))
+        sys.exit(0)
+
+    file_path = tool_input.get("file_path", "")
+    if not file_path:
+        print(json.dumps({}))
+        sys.exit(0)
+
+    source_file = Path(file_path)
+
+    # Skip test files
+    if any(pattern in file_path.lower() for pattern in ["test", "spec", "__mocks__"]):
+        print(json.dumps({}))
+        sys.exit(0)
+
+    # Check language
+    checker = CoverageChecker(source_file)
+
+    if not checker.language:
+        print(json.dumps({}))
+        sys.exit(0)
+
+    # Only support Python, TypeScript, JavaScript
+    if checker.language not in ("Python", "TypeScript", "JavaScript"):
+        print(json.dumps({}))
+        sys.exit(0)
+
+    # Check if test file exists
+    test_file = get_test_file_path(source_file)
+    output = {"hookSpecificOutput": {"hookEventName": "PostToolUse"}}
+
+    if not test_file or not Path(test_file).exists():
+        output["hookSpecificOutput"]["additionalContext"] = (
+            f"TDD ({checker.language}): No test file found.\n"
+            f"Expected: {test_file if test_file else 'N/A'}\n"
+            f"Create test file to enable coverage checking."
+        )
+        print(json.dumps(output))
+        sys.exit(2)  # Warning but don't block
+
+    # Run coverage check
+    coverage = checker.check_coverage()
+
+    if coverage.get("skipped"):
+        # Coverage check failed - don't block
+        output["hookSpecificOutput"]["additionalContext"] = (
+            f"Coverage check unavailable: {coverage.get('error', 'Unknown')}"
+        )
+        print(json.dumps(output))
+        sys.exit(0)
+
+    if "error" in coverage:
+        # Error but not skipped - report but don't block
+        output["hookSpecificOutput"]["additionalContext"] = f"Coverage check failed: {coverage['error']}"
+        print(json.dumps(output))
+        sys.exit(0)
+
+    coverage_percent = coverage.get("percent_covered", 0)
+    target = get_coverage_target()
+    tool = coverage.get("tool", "unknown")
+
+    if coverage_percent < target:
+        output["hookSpecificOutput"]["additionalContext"] = (
+            f"Coverage: {coverage_percent:.1f}% (target: {target}%)\n"
+            f"Tool: {tool}\n"
+            f"Language: {checker.language}\n"
+            f"File: {source_file.name}\n"
+            f"Test: {test_file}"
+        )
+        print(json.dumps(output))
+        sys.exit(2)  # Warn but don't block
+
+    # All good
+    output["hookSpecificOutput"]["additionalContext"] = (
+        f"Coverage: {coverage_percent:.1f}% ({checker.language}, {tool})"
+    )
+    print(json.dumps(output))
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

moai_adk/templates/.claude/hooks/moai/post_tool__linter.py

@@ -0,0 +1,315 @@
+#!/usr/bin/env python3
+"""PostToolUse Hook: Automatic Linting
+
+Claude Code Event: PostToolUse
+Matcher: Write|Edit
+Purpose: Automatically run linters after Claude writes or edits files
+
+Provides feedback to Claude about code quality issues:
+- Python: ruff check, mypy
+- JavaScript/TypeScript: eslint, biome lint
+- Go: golangci-lint
+- Rust: clippy
+- And many more...
+
+Exit Codes:
+- 0: Success (linting completed, issues reported as context)
+- 2: Critical lint errors (Claude should address immediately)
+
+Output:
+- JSON with additionalContext containing lint issues
+- Exit code 2 triggers Claude to review and fix issues
+"""
+
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+from typing import Any
+
+# Setup import path for shared modules
+HOOKS_DIR = Path(__file__).parent
+LIB_DIR = HOOKS_DIR / "lib"
+if str(LIB_DIR) not in sys.path:
+    sys.path.insert(0, str(LIB_DIR))
+
+# Try importing tool_registry, with fallback
+try:
+    import tool_registry  # noqa: F401
+
+    TOOL_REGISTRY_AVAILABLE = True
+except ImportError:
+    TOOL_REGISTRY_AVAILABLE = False
+
+    # Fallback definitions
+    class ToolType:
+        LINTER = "linter"
+
+    class ToolResult:
+        def __init__(self, **kwargs):
+            for k, v in kwargs.items():
+                setattr(self, k, v)
+
+
+# Maximum number of issues to report to Claude
+MAX_ISSUES_TO_REPORT = 5
+
+# File extensions that should skip linting
+SKIP_EXTENSIONS = {
+    ".json",
+    ".lock",
+    ".min.js",
+    ".min.css",
+    ".map",
+    ".svg",
+    ".png",
+    ".jpg",
+    ".gif",
+    ".ico",
+    ".woff",
+    ".woff2",
+    ".ttf",
+    ".eot",
+    ".md",  # Markdown usually doesn't need linting for code generation
+}
+
+# Directories to skip
+SKIP_DIRECTORIES = {
+    "node_modules",
+    ".git",
+    ".venv",
+    "venv",
+    "__pycache__",
+    ".cache",
+    "dist",
+    "build",
+    ".next",
+    ".nuxt",
+    "target",
+    "vendor",
+}
+
+
+def should_skip_file(file_path: str) -> tuple[bool, str]:
+    """Check if file should be skipped for linting.
+
+    Args:
+        file_path: Path to the file
+
+    Returns:
+        Tuple of (should_skip, reason)
+    """
+    path = Path(file_path)
+
+    # Check extension
+    if path.suffix.lower() in SKIP_EXTENSIONS:
+        return True, f"Skipped: {path.suffix} files are not linted"
+
+    # Check for minified files
+    if ".min." in path.name:
+        return True, "Skipped: minified file"
+
+    # Check if in skip directory
+    for parent in path.parents:
+        if parent.name in SKIP_DIRECTORIES:
+            return True, f"Skipped: file in {parent.name}/ directory"
+
+    # Check if file exists
+    if not path.exists():
+        return True, "Skipped: file does not exist"
+
+    return False, ""
+
+
+def parse_lint_output(output: str, error: str) -> list[dict[str, Any]]:
+    """Parse linter output to extract issues.
+
+    Args:
+        output: stdout from linter
+        error: stderr from linter
+
+    Returns:
+        List of parsed issues
+    """
+    issues: list[dict[str, Any]] = []
+    combined = (output + "\n" + error).strip()
+
+    if not combined:
+        return issues
+
+    # Parse line by line
+    for line in combined.split("\n"):
+        line = line.strip()
+        if not line:
+            continue
+
+        # Skip non-issue lines
+        if any(
+            skip in line.lower()
+            for skip in [
+                "warning:",
+                "info:",
+                "running",
+                "checking",
+                "finished",
+                "success",
+                "✓",
+                "✔",
+            ]
+        ):
+            continue
+
+        # Look for error patterns
+        if "error" in line.lower() or ":" in line:
+            issues.append({"message": line[:200]})  # Truncate long messages
+
+        if len(issues) >= MAX_ISSUES_TO_REPORT:
+            break
+
+    return issues
+
+
+def lint_file(file_path: str) -> dict[str, Any]:
+    """Lint a single file using the appropriate linter.
+
+    Args:
+        file_path: Path to the file to lint
+
+    Returns:
+        Dictionary with linting results
+    """
+    results: dict[str, Any] = {
+        "file": file_path,
+        "linted": False,
+        "issues": [],
+        "issues_fixed": 0,
+        "tools_run": [],
+        "errors": [],
+    }
+
+    # Check if we should skip
+    should_skip, skip_reason = should_skip_file(file_path)
+    if should_skip:
+        results["skipped"] = True
+        results["skip_reason"] = skip_reason
+        return results
+
+    # Get tool registry
+    if not TOOL_REGISTRY_AVAILABLE:
+        results["errors"].append("Tool registry not available")
+        return results
+
+    registry = tool_registry.get_tool_registry()
+    if not registry:
+        results["errors"].append("Tool registry not available")
+        return results
+
+    # Get linters for this file
+    linters = registry.get_tools_for_file(file_path, ToolType.LINTER)
+    if not linters:
+        language = registry.get_language_for_file(file_path)
+        if language:
+            results["skipped"] = True
+            results["skip_reason"] = f"No linter available for {language}"
+        else:
+            results["skipped"] = True
+            results["skip_reason"] = "Unknown file type"
+        return results
+
+    # Run linters (use first available)
+    for linter in linters[:1]:  # Only run the highest priority linter
+        result = registry.run_tool(linter, file_path)
+        results["tools_run"].append(
+            {
+                "name": result.tool_name,
+                "success": result.success,
+                "fixed": result.file_modified,
+            }
+        )
+
+        results["linted"] = True
+
+        if result.file_modified:
+            results["issues_fixed"] += 1
+
+        # Parse issues from output
+        if result.output or result.error:
+            parsed_issues = parse_lint_output(result.output, result.error)
+            results["issues"].extend(parsed_issues)
+
+        break  # Only use first linter
+
+    return results
+
+
+def main() -> None:
+    """Main entry point for PostToolUse linter hook.
+
+    Reads JSON input from stdin, lints the file if applicable,
+    and outputs JSON result for Claude.
+    """
+    try:
+        # Read JSON input from stdin
+        input_data = json.load(sys.stdin)
+    except json.JSONDecodeError:
+        # Invalid JSON input - exit silently
+        sys.exit(0)
+
+    # Extract tool information
+    tool_name = input_data.get("tool_name", "")
+    tool_input = input_data.get("tool_input", {})
+
+    # Only process Write and Edit tools
+    if tool_name not in ("Write", "Edit"):
+        sys.exit(0)
+
+    # Get file path from tool input
+    file_path = tool_input.get("file_path", "")
+    if not file_path:
+        sys.exit(0)
+
+    # Lint the file
+    result = lint_file(file_path)
+
+    # Build output
+    output: dict[str, Any] = {}
+
+    if result.get("issues"):
+        # Issues found - provide context to Claude
+        issue_count = len(result["issues"])
+        issue_summary = "; ".join([i["message"] for i in result["issues"][:3]])
+
+        if issue_count > 3:
+            issue_summary += f" (+{issue_count - 3} more)"
+
+        # If issues were auto-fixed, just inform
+        if result.get("issues_fixed", 0) > 0:
+            output = {
+                "hookSpecificOutput": {
+                    "hookEventName": "PostToolUse",
+                    "additionalContext": f"Lint: {result['issues_fixed']} issues auto-fixed",
+                }
+            }
+            print(json.dumps(output))
+            sys.exit(0)
+        else:
+            # Issues need attention - use exit code 2 to alert Claude
+            print(f"Lint issues found: {issue_summary}", file=sys.stderr)
+            sys.exit(2)
+
+    elif result.get("linted"):
+        # Linting passed with no issues
+        output = {"suppressOutput": True}
+        print(json.dumps(output))
+        sys.exit(0)
+
+    else:
+        # Skipped or no linter available
+        output = {"suppressOutput": True}
+        print(json.dumps(output))
+        sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()