#!/usr/bin/env python3
# /usr/local/bin/post_edit_hook.py
# Runs linters and formatters after Claude edits files

import sys
import json
import subprocess
import os
from pathlib import Path

def get_file_path(tool_input: dict) -> str | None:
    return tool_input.get("file_path") or tool_input.get("path")

def run_formatter(file_path: str) -> tuple[bool, str]:
    """Run the appropriate formatter for the file type."""
    ext = Path(file_path).suffix.lower()
    formatters = {
        ".py": ["ruff", "format", "--quiet", file_path],
        ".ts": ["prettier", "--write", "--quiet", file_path],
        ".tsx": ["prettier", "--write", "--quiet", file_path],
        ".js": ["prettier", "--write", "--quiet", file_path],
        ".go": ["gofmt", "-w", file_path],
        ".rs": ["rustfmt", "--quiet", file_path],
    }
    cmd = formatters.get(ext)
    if not cmd:
        return True, ""

    result = subprocess.run(cmd, capture_output=True, text=True)
    return result.returncode == 0, result.stderr

def run_linter(file_path: str) -> tuple[bool, str]:
    """Run the appropriate linter."""
    ext = Path(file_path).suffix.lower()
    linters = {
        ".py": ["ruff", "check", "--quiet", file_path],
        ".ts": ["eslint", "--quiet", file_path],
        ".tsx": ["eslint", "--quiet", file_path],
        ".go": ["go", "vet", file_path],
    }
    cmd = linters.get(ext)
    if not cmd:
        return True, ""

    result = subprocess.run(cmd, capture_output=True, text=True)
    return result.returncode == 0, result.stdout + result.stderr

def main():
    try:
        data = json.load(sys.stdin)
    except json.JSONDecodeError:
        sys.exit(0)

    tool_name = data.get("tool_name", "")
    tool_input = data.get("tool_input", {})

    # Only run on file write/edit operations
    if tool_name not in ("Write", "Edit", "NotebookEdit"):
        sys.exit(0)

    file_path = get_file_path(tool_input)
    if not file_path or not Path(file_path).exists():
        sys.exit(0)

    # Run formatter
    fmt_ok, fmt_err = run_formatter(file_path)
    if not fmt_ok:
        print(f"[hook] Formatter warning for {file_path}: {fmt_err}", file=sys.stderr)

    # Run linter
    lint_ok, lint_output = run_linter(file_path)
    if not lint_ok:
        # Log lint errors — PostToolUse can't block but can log
        print(f"[hook] Lint issues in {file_path}:", file=sys.stderr)
        print(lint_output, file=sys.stderr)

        # Write lint errors to a file Claude can read in next turn
        with open("/tmp/claude_lint_errors.txt", "a") as f:
            f.write(f"=== {file_path} ===\n{lint_output}\n")

if __name__ == "__main__":
    main()

#!/usr/bin/env python3
# /usr/local/bin/run_related_tests.py
# Finds and runs tests related to the file Claude just edited

import sys
import json
import subprocess
from pathlib import Path
import re

def find_related_test_files(source_path: str) -> list[str]:
    """Find test files that test a given source file."""
    p = Path(source_path)
    candidates = []

    # Python: tests/test_<module>.py or tests/<module>_test.py
    if p.suffix == ".py":
        name = p.stem
        candidates = [
            f"tests/test_{name}.py",
            f"tests/{name}_test.py",
            f"test_{name}.py",
        ]

    # Go: <file>_test.go in same directory
    elif p.suffix == ".go" and not p.stem.endswith("_test"):
        candidates = [str(p.parent / f"{p.stem}_test.go")]

    # TypeScript/JavaScript
    elif p.suffix in (".ts", ".tsx", ".js"):
        name = p.stem
        candidates = [
            f"{p.parent}/{name}.test{p.suffix}",
            f"{p.parent}/{name}.spec{p.suffix}",
            f"__tests__/{name}{p.suffix}",
        ]

    return [c for c in candidates if Path(c).exists()]

def run_tests(test_files: list[str], source_file: str) -> dict:
    if not test_files:
        return {"ran": False, "reason": "no related test files found"}

    # Determine test runner from project
    if Path("pytest.ini").exists() or Path("pyproject.toml").exists():
        cmd = ["pytest", "--tb=short", "-q"] + test_files
    elif Path("package.json").exists():
        cmd = ["npx", "jest", "--passWithNoTests"] + test_files
    elif source_file.endswith(".go"):
        cmd = ["go", "test", "./..."]
    else:
        return {"ran": False, "reason": "unknown test runner"}

    result = subprocess.run(cmd, capture_output=True, text=True, timeout=120)
    return {
        "ran": True,
        "passed": result.returncode == 0,
        "output": result.stdout[-2000:],  # Last 2000 chars
        "test_files": test_files
    }

def main():
    try:
        data = json.load(sys.stdin)
    except Exception:
        sys.exit(0)

    file_path = (data.get("tool_input", {}).get("file_path") or
                 data.get("tool_input", {}).get("path", ""))

    if not file_path:
        sys.exit(0)

    test_files = find_related_test_files(file_path)
    result = run_tests(test_files, file_path)

    if result["ran"]:
        status = "PASSED" if result["passed"] else "FAILED"
        print(f"[hook] Tests {status} for {Path(file_path).name}")
        if not result["passed"]:
            # Write failures to temp file for Claude to pick up
            with open("/tmp/claude_test_failures.txt", "w") as f:
                f.write(result["output"])
            print(result["output"])

if __name__ == "__main__":
    main()

#!/usr/bin/env python3
# /usr/local/bin/notify_hook.py

import sys
import json
import subprocess
import os
import platform

def send_desktop_notification(title: str, message: str):
    system = platform.system()
    if system == "Darwin":
        subprocess.run([
            "osascript", "-e",
            f'display notification "{message}" with title "{title}"'
        ])
    elif system == "Linux":
        subprocess.run(["notify-send", title, message])

def send_slack_notification(message: str):
    webhook = os.environ.get("SLACK_WEBHOOK_URL")
    if not webhook:
        return
    import urllib.request
    req = urllib.request.Request(
        webhook,
        data=json.dumps({"text": f":robot_face: Claude Code: {message}"}).encode(),
        headers={"Content-Type": "application/json"}
    )
    urllib.request.urlopen(req, timeout=5)

def main():
    try:
        data = json.load(sys.stdin)
    except Exception:
        sys.exit(0)

    message = data.get("message", "Needs your attention")
    send_desktop_notification("Claude Code", message[:100])

    # Only Slack for important messages
    if any(word in message.lower() for word in ["error", "failed", "blocked", "need"]):
        send_slack_notification(message[:200])

if __name__ == "__main__":
    main()