claude-dev-env 1.38.1 → 1.40.0

package/skills/bugteam/scripts/bugteam_fix_hookspath.py

@@ -0,0 +1,375 @@
+from __future__ import annotations
+
+import argparse
+import subprocess
+import sys
+from pathlib import Path
+
+for each_cached_module_name in [
+    each_module_key
+    for each_module_key in list(sys.modules)
+    if each_module_key == "config" or each_module_key.startswith("config.")
+]:
+    sys.modules.pop(each_cached_module_name, None)
+if str(Path(__file__).resolve().parent) not in sys.path:
+    sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+from config.bugteam_fix_hookspath_constants import (
+    ALL_CANONICAL_HOOKS_DIRECTORY_COMPONENTS,
+    ALL_GLOBAL_HOOKS_PATH_ARGUMENTS,
+    ALL_HOME_ENV_VAR_NAMES,
+    GIT_DIRECTORY_NAME,
+    HOOKS_PATH_SUFFIX,
+    PREFLIGHT_NO_PYTEST_FLAG,
+    PREFLIGHT_REPO_ROOT_FLAG,
+)
+
+
+def _expected_hooks_path_suffix() -> str:
+    return HOOKS_PATH_SUFFIX
+
+
+def _canonical_hooks_directory_components() -> tuple[str, str, str]:
+    return ALL_CANONICAL_HOOKS_DIRECTORY_COMPONENTS
+
+
+def _home_env_var_names() -> tuple[str, str]:
+    return ALL_HOME_ENV_VAR_NAMES
+
+
+def resolve_canonical_hooks_directory(
+    all_environment_overrides: dict[str, str] | None,
+) -> Path:
+    """Resolve the canonical hooks directory under the user's home directory.
+
+    When environment overrides are provided, checks HOME/USERPROFILE overrides
+    first before falling back to pathlib.Path.home().
+
+    Args:
+        all_environment_overrides: Optional dict of environment variable
+            overrides for resolving the home directory.
+
+    Returns:
+        The resolved Path to the canonical hooks directory.
+    """
+    components = _canonical_hooks_directory_components()
+    if all_environment_overrides is not None:
+        for each_env_var_name in _home_env_var_names():
+            home_value = all_environment_overrides.get(each_env_var_name)
+            if home_value:
+                return Path(home_value).joinpath(*components)
+    return Path.home().joinpath(*components)
+
+
+def list_local_core_hooks_path_values(
+    repository_root: Path,
+    all_environment_overrides: dict[str, str] | None,
+) -> list[str]:
+    """Retrieve the local core.hooksPath values for a given repository.
+
+    Args:
+        repository_root: The repository root for running git config.
+        all_environment_overrides: Optional env overrides for git.
+
+    Returns:
+        List of local core.hooksPath strings, or empty list when unset.
+
+    Raises:
+        RuntimeError: When git emits a non-zero exit with non-empty stderr;
+            distinguishes a real git failure from the expected "key unset"
+            case (exit 1 with empty stderr).
+    """
+    git_command = [
+        "git",
+        "-C",
+        str(repository_root),
+        "config",
+        "--local",
+        "--get-all",
+        "core.hooksPath",
+    ]
+    completed_process = subprocess.run(
+        git_command,
+        capture_output=True,
+        text=True,
+        encoding="utf-8",
+        errors="replace",
+        check=False,
+        env=all_environment_overrides,
+    )
+    if completed_process.returncode != 0:
+        if completed_process.stderr.strip():
+            raise RuntimeError(
+                f"git config --local --get-all core.hooksPath failed on "
+                f"{repository_root} (exit {completed_process.returncode}): "
+                f"{completed_process.stderr.strip()}"
+            )
+        return []
+    return [
+        each_line.strip()
+        for each_line in completed_process.stdout.splitlines()
+        if each_line.strip()
+    ]
+
+
+def read_global_core_hooks_path(
+    all_environment_overrides: dict[str, str] | None,
+) -> str:
+    """Read the global core.hooksPath git configuration value.
+
+    Args:
+        all_environment_overrides: Optional env overrides for git.
+
+    Returns:
+        The global core.hooksPath value, or empty string when unset.
+
+    Raises:
+        RuntimeError: When git emits a non-zero exit with non-empty stderr;
+            distinguishes a real git failure from the expected "key unset"
+            case (exit 1 with empty stderr).
+    """
+    completed_process = subprocess.run(
+        list(ALL_GLOBAL_HOOKS_PATH_ARGUMENTS),
+        capture_output=True,
+        text=True,
+        encoding="utf-8",
+        errors="replace",
+        check=False,
+        env=all_environment_overrides,
+    )
+    if completed_process.returncode != 0:
+        if completed_process.stderr.strip():
+            raise RuntimeError(
+                f"git config --global --get core.hooksPath failed "
+                f"(exit {completed_process.returncode}): "
+                f"{completed_process.stderr.strip()}"
+            )
+        return ""
+    return completed_process.stdout.strip()
+
+
+def unset_local_core_hooks_path(
+    repository_root: Path,
+    all_environment_overrides: dict[str, str] | None,
+) -> int:
+    """Remove the local core.hooksPath configuration for a repository.
+
+    Args:
+        repository_root: The repository root for running git config.
+        all_environment_overrides: Optional env overrides for git.
+
+    Returns:
+        The git exit code (0 on success, non-zero on failure).
+    """
+    git_command = [
+        "git",
+        "-C",
+        str(repository_root),
+        "config",
+        "--local",
+        "--unset-all",
+        "core.hooksPath",
+    ]
+    completed_process = subprocess.run(
+        git_command,
+        capture_output=True,
+        text=True,
+        check=False,
+        env=all_environment_overrides,
+    )
+    return completed_process.returncode
+
+
+def set_global_core_hooks_path(
+    target_value: str,
+    all_environment_overrides: dict[str, str] | None,
+) -> int:
+    """Set the global core.hooksPath git configuration value.
+
+    Args:
+        target_value: The hooks path value to set globally.
+        all_environment_overrides: Optional env overrides for git.
+
+    Returns:
+        The git exit code (0 on success, non-zero on failure).
+    """
+    git_command = ["git", "config", "--global", "core.hooksPath", target_value]
+    completed_process = subprocess.run(
+        git_command,
+        capture_output=True,
+        text=True,
+        check=False,
+        env=all_environment_overrides,
+    )
+    return completed_process.returncode
+
+
+def normalize_hooks_path(raw_value: str) -> str:
+    return raw_value.replace("\\", "/").rstrip("/")
+
+
+def is_canonical_hooks_path(raw_value: str) -> bool:
+    if not raw_value:
+        return False
+    return normalize_hooks_path(raw_value).endswith(_expected_hooks_path_suffix())
+
+
+def find_repository_root(start: Path) -> Path:
+    """Find the repository root by walking up from the starting directory.
+
+    Searches for a ``.git`` directory or file in parent directories.
+
+    Args:
+        start: The directory to start searching from.
+
+    Returns:
+        The repository root path, or *start* when no repository is found.
+    """
+    resolved_start = start.resolve()
+    candidate_paths = [resolved_start, *resolved_start.parents]
+    for each_candidate in candidate_paths:
+        marker = each_candidate / GIT_DIRECTORY_NAME
+        if marker.is_dir() or marker.is_file():
+            return each_candidate
+    return resolved_start
+
+
+def rerun_preflight(
+    repository_root: Path,
+    all_environment_overrides: dict[str, str] | None,
+) -> int:
+    """Re-run bugteam_preflight.py after fixing core.hooksPath.
+
+    Args:
+        repository_root: The repository root to pass to preflight.
+        all_environment_overrides: Optional env overrides for the subprocess.
+
+    Returns:
+        The preflight exit code (0 on success, non-zero on failure).
+    """
+    preflight_script_path = Path(__file__).resolve().parent / "bugteam_preflight.py"
+    rerun_command = [
+        sys.executable,
+        str(preflight_script_path),
+        PREFLIGHT_NO_PYTEST_FLAG,
+        PREFLIGHT_REPO_ROOT_FLAG,
+        str(repository_root),
+    ]
+    completed_process = subprocess.run(
+        rerun_command,
+        check=False,
+        env=all_environment_overrides,
+    )
+    return completed_process.returncode
+
+
+def parse_arguments(all_argv: list[str] | None) -> argparse.Namespace:
+    """Parse command-line arguments for the hooks-path fix script.
+
+    Args:
+        all_argv: Command-line argument list (pass None for defaults).
+
+    Returns:
+        Parsed namespace with the repo_root attribute.
+    """
+    parser = argparse.ArgumentParser(
+        description=(
+            "Auto-fix core.hooksPath when bugteam preflight detects a stale override. "
+            "Removes a local-scope override and ensures global core.hooksPath points "
+            "at the canonical claude-dev-env git-hooks directory."
+        ),
+    )
+    parser.add_argument(
+        "--repo-root",
+        type=Path,
+        default=None,
+        help="Repository root (default: discover from cwd).",
+    )
+    return parser.parse_args(all_argv)
+
+
+def main(
+    all_argv: list[str] | None,
+    *,
+    all_environment_overrides: dict[str, str] | None,
+) -> int:
+    """Fix core.hooksPath and rerun bugteam preflight.
+
+    Resolves the canonical hooks directory, checks for stale local overrides,
+    removes them if found, ensures global core.hooksPath is correct, then
+    reruns bugteam_preflight to verify.
+
+    Args:
+        all_argv: Command-line arguments to parse.
+        all_environment_overrides: Optional environment overrides for git.
+
+    Returns:
+        Zero on success, non-zero on failure.
+    """
+    arguments = parse_arguments(all_argv)
+    start_directory = Path.cwd()
+    repository_root = (
+        arguments.repo_root.resolve()
+        if arguments.repo_root is not None
+        else find_repository_root(start_directory)
+    )
+    canonical_hooks_directory = resolve_canonical_hooks_directory(all_environment_overrides)
+    expected_suffix = _expected_hooks_path_suffix()
+    if not canonical_hooks_directory.is_dir():
+        print(
+            "bugteam_fix_hookspath: canonical hooks directory does not exist: "
+            f"{canonical_hooks_directory}\n"
+            "Run: npx claude-dev-env .\n"
+            "Then re-run /bugteam. The directory must end in "
+            f"'{expected_suffix}' and contain the claude-dev-env git hook shims.",
+            file=sys.stderr,
+        )
+        return 1
+    local_hooks_path_values = list_local_core_hooks_path_values(
+        repository_root,
+        all_environment_overrides,
+    )
+    has_non_canonical_local_override = any(
+        not is_canonical_hooks_path(each_value)
+        for each_value in local_hooks_path_values
+    )
+    if has_non_canonical_local_override:
+        unset_local_returncode = unset_local_core_hooks_path(
+            repository_root, all_environment_overrides
+        )
+        if unset_local_returncode != 0:
+            print(
+                "bugteam_fix_hookspath: failed to unset local core.hooksPath on "
+                f"{repository_root} (git exit {unset_local_returncode}).",
+                file=sys.stderr,
+            )
+            return 1
+        print(
+            "bugteam_fix_hookspath: removed stale local core.hooksPath override on "
+            f"{repository_root}",
+            file=sys.stderr,
+        )
+    current_global_value = read_global_core_hooks_path(all_environment_overrides)
+    if not is_canonical_hooks_path(current_global_value):
+        canonical_target_value = str(canonical_hooks_directory).replace("\\", "/")
+        global_set_exit_code = set_global_core_hooks_path(
+            canonical_target_value,
+            all_environment_overrides,
+        )
+        if global_set_exit_code != 0:
+            print(
+                "bugteam_fix_hookspath: failed to set global core.hooksPath to "
+                f"{canonical_target_value} (git exit {global_set_exit_code}).",
+                file=sys.stderr,
+            )
+            return 1
+        print(
+            "bugteam_fix_hookspath: set global core.hooksPath to "
+            f"{canonical_target_value}",
+            file=sys.stderr,
+        )
+    return rerun_preflight(repository_root, all_environment_overrides)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main(None, all_environment_overrides=None))

package/skills/bugteam/scripts/bugteam_preflight.py

@@ -0,0 +1,328 @@
+from __future__ import annotations
+
+import argparse
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+for each_cached_module_name in [
+    each_module_key
+    for each_module_key in list(sys.modules)
+    if each_module_key == "config" or each_module_key.startswith("config.")
+]:
+    sys.modules.pop(each_cached_module_name, None)
+_bugteam_scripts_directory = str(Path(__file__).absolute().parent)
+while _bugteam_scripts_directory in sys.path:
+    sys.path.remove(_bugteam_scripts_directory)
+if _bugteam_scripts_directory not in sys.path:
+    sys.path.insert(0, _bugteam_scripts_directory)
+
+from config.bugteam_preflight_constants import (
+    ALL_DISCOVERY_IGNORE_DIRECTORIES,
+    ALL_GIT_CONFIG_HOOKS_PATH_ARGUMENTS,
+    ALL_PRE_COMMIT_ARGUMENTS,
+    BUGTEAM_PREFLIGHT_PREFIX,
+    BUGTEAM_PREFLIGHT_SKIP_ENV_VAR_NAME,
+    ENFORCEMENT_ABSENT_MESSAGE,
+    EXIT_CODE_HOOKS_PATH_CHECK_FAILED,
+    EXPECTED_HOOKS_PATH_SUFFIX,
+    GIT_DIRECTORY_NAME,
+    PRE_COMMIT_CONFIG_FILENAME,
+    PYPROJECT_FILENAME,
+    PYPROJECT_PYTEST_SECTION_PREFIX,
+    PYTEST_EXIT_CODE_NO_TESTS_COLLECTED,
+    PYTEST_INI_FILENAME,
+)
+
+for each_cached_module_name in [
+    each_module_key
+    for each_module_key in list(sys.modules)
+    if each_module_key == "config" or each_module_key.startswith("config.")
+]:
+    sys.modules.pop(each_cached_module_name, None)
+_shared_pr_loop_scripts_directory = (
+    Path(__file__).absolute().parent
+    / ".." / ".." / ".." / "_shared" / "pr-loop" / "scripts"
+).absolute()
+if str(_shared_pr_loop_scripts_directory) not in sys.path:
+    sys.path.insert(0, str(_shared_pr_loop_scripts_directory))
+
+from reviews_disabled import (
+    CLAUDE_REVIEWS_DISABLED_BUGTEAM_TOKEN,
+    CLAUDE_REVIEWS_DISABLED_ENV_VAR_NAME,
+    EXIT_CODE_BUGTEAM_DISABLED_VIA_ENV,
+    is_bugteam_disabled_via_env,
+)
+
+
+def verify_git_hooks_path(repository_root: Path | None) -> int:
+    """Check that core.hooksPath resolves to the claude-dev-env git-hooks directory.
+
+    When *repository_root* is provided, queries the effective config for that
+    repository (``git -C <root> config --get``), which detects repo-level
+    overrides such as Husky or lefthook. Falls back to the current working
+    directory's effective config when *repository_root* is None.
+
+    Args:
+        repository_root: Optional repository root to check. When None, uses
+            the current working directory's effective config.
+
+    Returns:
+        Zero when the configured path ends with the expected hooks suffix.
+        Non-zero and prints a correction message when unset or pointing elsewhere.
+    """
+    git_command: list[str] = ["git"]
+    if repository_root is not None:
+        git_command.extend(["-C", str(repository_root)])
+    git_command.extend(list(ALL_GIT_CONFIG_HOOKS_PATH_ARGUMENTS))
+    try:
+        query_result = subprocess.run(
+            git_command,
+            capture_output=True,
+            text=True,
+            encoding="utf-8",
+            errors="replace",
+            check=False,
+        )
+    except FileNotFoundError:
+        print(
+            f"{BUGTEAM_PREFLIGHT_PREFIX}git is not installed or not available on PATH.\n"
+            f"{ENFORCEMENT_ABSENT_MESSAGE}",
+            file=sys.stderr,
+        )
+        return EXIT_CODE_HOOKS_PATH_CHECK_FAILED
+    except OSError as os_error:
+        print(
+            f"{BUGTEAM_PREFLIGHT_PREFIX}failed to run git: {os_error}\n"
+            f"{ENFORCEMENT_ABSENT_MESSAGE}",
+            file=sys.stderr,
+        )
+        return EXIT_CODE_HOOKS_PATH_CHECK_FAILED
+    if query_result.returncode != 0:
+        print(
+            f"{BUGTEAM_PREFLIGHT_PREFIX}{ENFORCEMENT_ABSENT_MESSAGE}",
+            file=sys.stderr,
+        )
+        return EXIT_CODE_HOOKS_PATH_CHECK_FAILED
+    configured_path = query_result.stdout.strip().replace("\\", "/").rstrip("/")
+    if not configured_path.endswith(EXPECTED_HOOKS_PATH_SUFFIX):
+        print(
+            f"{BUGTEAM_PREFLIGHT_PREFIX}core.hooksPath is '{configured_path}' — "
+            f"expected path ending in '{EXPECTED_HOOKS_PATH_SUFFIX}'.\n"
+            f"{ENFORCEMENT_ABSENT_MESSAGE}",
+            file=sys.stderr,
+        )
+        return EXIT_CODE_HOOKS_PATH_CHECK_FAILED
+    return 0
+
+
+def find_repository_root(start: Path) -> Path:
+    """Find the repository root by walking up from the starting directory.
+
+    Searches for a ``.git`` directory or file in parent directories. Falls
+    back to the nearest ancestor containing ``pytest.ini`` when no git
+    repository is found.
+
+    Args:
+        start: The directory to start searching from.
+
+    Returns:
+        The repository root path, or *start* when no repository is found.
+    """
+    resolved = start.resolve()
+    candidates = [resolved, *resolved.parents]
+    for each_candidate in candidates:
+        if (each_candidate / GIT_DIRECTORY_NAME).is_dir() or (each_candidate / GIT_DIRECTORY_NAME).is_file():
+            return each_candidate
+    for each_candidate in candidates:
+        if (each_candidate / PYTEST_INI_FILENAME).is_file():
+            return each_candidate
+    return resolved
+
+
+def has_pytest_configuration(root: Path) -> bool:
+    """Check whether a directory has pytest configuration available.
+
+    Checks for ``pytest.ini`` directly, then falls back to searching for
+    ``[tool.pytest]`` in ``pyproject.toml``.
+
+    Args:
+        root: The directory to check for pytest configuration.
+
+    Returns:
+        True when pytest configuration is found in either location.
+    """
+    if (root / PYTEST_INI_FILENAME).is_file():
+        return True
+    pyproject = root / PYPROJECT_FILENAME
+    if not pyproject.is_file():
+        return False
+    text = pyproject.read_text(encoding="utf-8", errors="replace")
+    return PYPROJECT_PYTEST_SECTION_PREFIX in text
+
+
+def has_discoverable_tests(root: Path) -> bool:
+    """Check whether the directory tree contains discoverable test files.
+
+    Searches for files matching ``test_*.py`` and ``*_test.py`` patterns,
+    skipping directories in the configured ignore list (virtual environments,
+    node_modules).
+
+    Args:
+        root: The directory tree root to search.
+
+    Returns:
+        True when at least one test file is found outside ignored directories.
+    """
+    for each_path in root.rglob("test_*.py"):
+        if any(part_dir in ALL_DISCOVERY_IGNORE_DIRECTORIES for part_dir in each_path.parts):
+            continue
+        return True
+    for each_path in root.rglob("*_test.py"):
+        if any(part_dir in ALL_DISCOVERY_IGNORE_DIRECTORIES for part_dir in each_path.parts):
+            continue
+        return True
+    return False
+
+
+def _pytest_exit_code_no_tests_collected() -> int:
+    return PYTEST_EXIT_CODE_NO_TESTS_COLLECTED
+
+
+def run_pytest(repository_root: Path, verbose: bool) -> int:
+    """Run pytest in the repository root and return the exit code.
+
+    Treats the "no tests collected" exit code as a pass (exit 0).
+
+    Args:
+        repository_root: The repository root for running pytest.
+        verbose: When True, pass no -q flag (shows individual test names).
+
+    Returns:
+        The pytest exit code, or 0 when no tests were collected.
+    """
+    command = [sys.executable, "-m", "pytest"]
+    if not verbose:
+        command.append("-q")
+    completed = subprocess.run(
+        command,
+        cwd=str(repository_root),
+        check=False,
+    )
+    if completed.returncode == _pytest_exit_code_no_tests_collected():
+        return 0
+    return completed.returncode
+
+
+def run_pre_commit(repository_root: Path) -> int:
+    """Run pre-commit on all files and return the exit code.
+
+    Args:
+        repository_root: The repository root for running pre-commit.
+
+    Returns:
+        The pre-commit exit code (0 on success, non-zero on failure).
+    """
+    completed = subprocess.run(
+        ALL_PRE_COMMIT_ARGUMENTS,
+        cwd=str(repository_root),
+        check=False,
+    )
+    return completed.returncode
+
+
+def parse_arguments(all_argv: list[str]) -> argparse.Namespace:
+    """Parse command-line arguments for the preflight script.
+
+    Args:
+        all_argv: Command-line argument list.
+
+    Returns:
+        Parsed namespace with repo_root, no_pytest, pre_commit, and verbose.
+    """
+    parser = argparse.ArgumentParser(
+        description="Run local checks before /bugteam (pytest, optional pre-commit).",
+    )
+    parser.add_argument(
+        "--repo-root",
+        type=Path,
+        default=None,
+        help="Repository root (default: discover from cwd).",
+    )
+    parser.add_argument(
+        "--no-pytest",
+        action="store_true",
+        help="Skip pytest.",
+    )
+    parser.add_argument(
+        "--pre-commit",
+        action="store_true",
+        help="Run pre-commit when .pre-commit-config.yaml exists.",
+    )
+    parser.add_argument(
+        "-v",
+        "--verbose",
+        action="store_true",
+        help="Verbose pytest output.",
+    )
+    return parser.parse_args(all_argv)
+
+
+def main(all_argv: list[str] | None = None) -> int:
+    """Run the bugteam preflight checks (pytest, optional pre-commit).
+
+    Args:
+        all_argv: Command-line arguments to parse. Pass None to use sys.argv.
+
+    Returns:
+        Zero on success, non-zero exit code on failure.
+    """
+    arguments = parse_arguments(sys.argv[1:] if all_argv is None else all_argv)
+    if os.environ.get(BUGTEAM_PREFLIGHT_SKIP_ENV_VAR_NAME, "").strip() == "1":
+        print(f"{BUGTEAM_PREFLIGHT_PREFIX}skipped (BUGTEAM_PREFLIGHT_SKIP=1).", file=sys.stderr)
+        return 0
+    reviews_disabled_env_var_name = CLAUDE_REVIEWS_DISABLED_ENV_VAR_NAME
+    reviews_disabled_bugteam_token = CLAUDE_REVIEWS_DISABLED_BUGTEAM_TOKEN
+    disabled_via_env_exit_code = EXIT_CODE_BUGTEAM_DISABLED_VIA_ENV
+    if is_bugteam_disabled_via_env():
+        print(
+            f"{BUGTEAM_PREFLIGHT_PREFIX}halted "
+            f"({reviews_disabled_env_var_name} contains "
+            f"'{reviews_disabled_bugteam_token}').",
+            file=sys.stderr,
+        )
+        return disabled_via_env_exit_code
+    start = Path.cwd()
+    resolved_repository_root: Path = (
+        arguments.repo_root.resolve()
+        if arguments.repo_root is not None
+        else find_repository_root(start)
+    )
+    hooks_path_exit_code = verify_git_hooks_path(resolved_repository_root)
+    if hooks_path_exit_code != 0:
+        return hooks_path_exit_code
+    if not arguments.no_pytest and has_pytest_configuration(resolved_repository_root):
+        if not has_discoverable_tests(resolved_repository_root):
+            print(
+                f"{BUGTEAM_PREFLIGHT_PREFIX}pytest configured but no tests found; skipping pytest.",
+                file=sys.stderr,
+            )
+        else:
+            exit_code = run_pytest(resolved_repository_root, arguments.verbose)
+            if exit_code != 0:
+                return exit_code
+    elif not arguments.no_pytest:
+        print(
+            f"{BUGTEAM_PREFLIGHT_PREFIX}no pytest configuration found; skipping pytest.",
+            file=sys.stderr,
+        )
+    if arguments.pre_commit and (resolved_repository_root / PRE_COMMIT_CONFIG_FILENAME).is_file():
+        exit_code = run_pre_commit(resolved_repository_root)
+        if exit_code != 0:
+            return exit_code
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main(sys.argv[1:]))