claude-dev-env 1.31.0 → 1.33.0

package/skills/bugteam/scripts/bugteam_code_rules_gate.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import argparse
+import ast
 import importlib.util
 import re
 import subprocess
@@ -239,6 +240,97 @@ def is_code_path(file_path: Path) -> bool:
     return suffix in {".py", ".js", ".ts", ".tsx", ".jsx"}
 
 
+def check_database_column_string_magic(content: str, file_path: str) -> list[str]:
+    """Flag string literals that look like database/HTTP column or key names inside function bodies.
+
+    Triggers when a snake_case string literal appears as the first element of a
+    two-element tuple inside a function body (the characteristic column-name/value
+    pair pattern). Files under ``config/`` and test files are exempt.
+    """
+    if "/config/" in file_path.replace("\\", "/") or "\\config\\" in file_path:
+        return []
+    if "/tests/" in file_path.replace("\\", "/") or file_path.endswith(("_test.py", ".spec.py")):
+        return []
+    try:
+        tree = ast.parse(content)
+    except SyntaxError:
+        return []
+    issues: list[str] = []
+    column_key_pattern = re.compile(r"^[a-z][a-z0-9_]{2,}$")
+    for node in ast.walk(tree):
+        if not isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+            continue
+        for each_child in ast.walk(node):
+            if not isinstance(each_child, ast.Tuple):
+                continue
+            if len(each_child.elts) != 2:
+                continue
+            first_element = each_child.elts[0]
+            if not isinstance(first_element, ast.Constant):
+                continue
+            if not isinstance(first_element.value, str):
+                continue
+            literal_text = first_element.value
+            if not column_key_pattern.match(literal_text):
+                continue
+            if literal_text in {"true", "false", "none", "null"}:
+                continue
+            issues.append(
+                f"Line {first_element.lineno}: Column-name string magic {literal_text!r} - extract to config"
+            )
+            if len(issues) >= 3:
+                return issues
+    return issues
+
+
+def check_wrapper_plumb_through(content: str, file_path: str) -> list[str]:
+    """Flag public wrappers that drop optional kwargs of a same-file delegate.
+
+    Walks the AST. For every public function (name does not start with '_'),
+    if its body contains exactly one direct call to another same-file
+    function and that delegate's signature accepts optional kwargs that the
+    wrapper does not also accept, emit a finding with both line numbers.
+    """
+    if file_path.endswith((".js", ".ts", ".tsx", ".jsx")):
+        return []
+    try:
+        tree = ast.parse(content)
+    except SyntaxError:
+        return []
+    function_signatures: dict[str, set[str]] = {}
+    for node in ast.walk(tree):
+        if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+            optional_kwargs: set[str] = set()
+            for each_kwonly, each_default in zip(node.args.kwonlyargs, node.args.kw_defaults):
+                if each_default is not None:
+                    optional_kwargs.add(each_kwonly.arg)
+            function_signatures[node.name] = optional_kwargs
+    issues: list[str] = []
+    for node in ast.walk(tree):
+        if not isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+            continue
+        if node.name.startswith("_"):
+            continue
+        wrapper_kwargs = function_signatures.get(node.name, set())
+        for each_call in ast.walk(node):
+            if not isinstance(each_call, ast.Call):
+                continue
+            if not isinstance(each_call.func, ast.Attribute):
+                continue
+            delegate_name = each_call.func.attr
+            delegate_kwargs = function_signatures.get(delegate_name)
+            if delegate_kwargs is None:
+                continue
+            missing = delegate_kwargs - wrapper_kwargs
+            if missing:
+                issues.append(
+                    f"Line {node.lineno}: Wrapper {node.name!r} drops optional kwargs {sorted(missing)!r} of delegate {delegate_name!r}"
+                )
+                if len(issues) >= 3:
+                    return issues
+    return issues
+
+
 def parse_added_line_numbers(unified_diff_text: str) -> set[int]:
     header_regex = hunk_header_pattern()
     added_line_numbers: set[int] = set()
@@ -404,6 +496,8 @@ def run_gate(
             continue
         relative = resolved.relative_to(repository_root.resolve())
         issues = validate_content(content, str(relative).replace("\\", "/"), old_content=content)
+        issues.extend(check_database_column_string_magic(content, str(relative).replace("\\", "/")))
+        issues.extend(check_wrapper_plumb_through(content, str(relative).replace("\\", "/")))
         if not issues:
             continue
         added_for_file = None if added_lines_map is None else added_lines_map.get(resolved)

package/skills/bugteam/scripts/bugteam_fix_hookspath.py

@@ -0,0 +1,260 @@
+from __future__ import annotations
+
+import argparse
+import subprocess
+import sys
+from pathlib import Path
+
+sys.modules.pop("config", 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_HOME_ENV_VAR_NAMES,
+    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(
+    environment_overrides: dict[str, str] | None,
+) -> Path:
+    components = _canonical_hooks_directory_components()
+    if environment_overrides is not None:
+        for each_env_var_name in _home_env_var_names():
+            home_value = 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,
+    environment_overrides: dict[str, str] | None,
+) -> list[str]:
+    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=environment_overrides,
+    )
+    if completed_process.returncode != 0:
+        return []
+    return [
+        each_line.strip()
+        for each_line in completed_process.stdout.splitlines()
+        if each_line.strip()
+    ]
+
+
+def read_global_core_hooks_path(
+    environment_overrides: dict[str, str] | None,
+) -> str:
+    git_command = ["git", "config", "--global", "--get", "core.hooksPath"]
+    completed_process = subprocess.run(
+        git_command,
+        capture_output=True,
+        text=True,
+        encoding="utf-8",
+        errors="replace",
+        check=False,
+        env=environment_overrides,
+    )
+    if completed_process.returncode != 0:
+        return ""
+    return completed_process.stdout.strip()
+
+
+def unset_local_core_hooks_path(
+    repository_root: Path,
+    environment_overrides: dict[str, str] | None,
+) -> int:
+    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=environment_overrides,
+    )
+    return completed_process.returncode
+
+
+def set_global_core_hooks_path(
+    target_value: str,
+    environment_overrides: dict[str, str] | None,
+) -> int:
+    git_command = ["git", "config", "--global", "core.hooksPath", target_value]
+    completed_process = subprocess.run(
+        git_command,
+        capture_output=True,
+        text=True,
+        check=False,
+        env=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:
+    resolved_start = start.resolve()
+    candidate_paths = [resolved_start, *resolved_start.parents]
+    for each_candidate in candidate_paths:
+        marker = each_candidate / ".git"
+        if marker.is_dir() or marker.is_file():
+            return each_candidate
+    return resolved_start
+
+
+def rerun_preflight(
+    repository_root: Path,
+    environment_overrides: dict[str, str] | None,
+) -> int:
+    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=environment_overrides,
+    )
+    return completed_process.returncode
+
+
+def parse_arguments(argv: list[str] | None) -> argparse.Namespace:
+    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(argv)
+
+
+def main(
+    argv: list[str] | None = None,
+    *,
+    environment_overrides: dict[str, str] | None = None,
+) -> int:
+    arguments = parse_arguments(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(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,
+        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, 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(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,
+            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, environment_overrides)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/skills/bugteam/scripts/config/bugteam_fix_hookspath_constants.py

@@ -0,0 +1,17 @@
+"""Configuration constants for bugteam_fix_hookspath auto-remediation script."""
+
+from __future__ import annotations
+
+HOOKS_PATH_SUFFIX: str = "hooks/git-hooks"
+
+ALL_CANONICAL_HOOKS_DIRECTORY_COMPONENTS: tuple[str, str, str] = (
+    ".claude",
+    "hooks",
+    "git-hooks",
+)
+
+ALL_HOME_ENV_VAR_NAMES: tuple[str, str] = ("HOME", "USERPROFILE")
+
+PREFLIGHT_NO_PYTEST_FLAG: str = "--no-pytest"
+
+PREFLIGHT_REPO_ROOT_FLAG: str = "--repo-root"

package/skills/bugteam/scripts/test_bugteam_fix_hookspath.py

@@ -0,0 +1,267 @@
+"""Tests for bugteam_fix_hookspath auto-remediation.
+
+Covers:
+- removes a local-scope core.hooksPath override and re-runs preflight
+- sets global core.hooksPath when missing
+- idempotent: second invocation produces the same final state with no errors
+- no-op when no override exists and global is already canonical
+- exits non-zero with a clear message when canonical hooks dir is missing
+"""
+
+from __future__ import annotations
+
+import importlib.util
+import os
+import subprocess
+from pathlib import Path
+from types import ModuleType
+
+import pytest
+
+
+def _load_fix_module() -> ModuleType:
+    module_path = Path(__file__).parent / "bugteam_fix_hookspath.py"
+    spec = importlib.util.spec_from_file_location("bugteam_fix_hookspath", module_path)
+    assert spec is not None
+    assert spec.loader is not None
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+bugteam_fix_hookspath = _load_fix_module()
+
+
+def _make_isolated_git_environment(home_directory: Path) -> dict[str, str]:
+    """Build an env dict that pins git's HOME and XDG paths into a tmp directory.
+
+    Without this, real `git config --global` reads/writes hit the developer's
+    actual ~/.gitconfig — which would corrupt the host machine and make tests
+    depend on global state. Pointing HOME, USERPROFILE, XDG_CONFIG_HOME, and
+    GIT_CONFIG_GLOBAL at a temp directory isolates the test fully.
+    """
+    isolated_environment = os.environ.copy()
+    isolated_environment["HOME"] = str(home_directory)
+    isolated_environment["USERPROFILE"] = str(home_directory)
+    isolated_environment["XDG_CONFIG_HOME"] = str(home_directory / ".config")
+    isolated_environment["GIT_CONFIG_GLOBAL"] = str(home_directory / ".gitconfig")
+    isolated_environment["GIT_CONFIG_NOSYSTEM"] = "1"
+    return isolated_environment
+
+
+def _initialize_repository(repository_path: Path, environment: dict[str, str]) -> None:
+    repository_path.mkdir(parents=True, exist_ok=True)
+    subprocess.run(
+        ["git", "init", "--quiet", str(repository_path)],
+        check=True,
+        env=environment,
+    )
+
+
+def _set_local_hooks_path(
+    repository_path: Path,
+    hooks_path_value: str,
+    environment: dict[str, str],
+) -> None:
+    subprocess.run(
+        [
+            "git",
+            "-C",
+            str(repository_path),
+            "config",
+            "--local",
+            "core.hooksPath",
+            hooks_path_value,
+        ],
+        check=True,
+        env=environment,
+    )
+
+
+def _set_global_hooks_path(hooks_path_value: str, environment: dict[str, str]) -> None:
+    subprocess.run(
+        ["git", "config", "--global", "core.hooksPath", hooks_path_value],
+        check=True,
+        env=environment,
+    )
+
+
+def _read_local_hooks_path(repository_path: Path, environment: dict[str, str]) -> str:
+    completed_process = subprocess.run(
+        [
+            "git",
+            "-C",
+            str(repository_path),
+            "config",
+            "--local",
+            "--get",
+            "core.hooksPath",
+        ],
+        capture_output=True,
+        text=True,
+        check=False,
+        env=environment,
+    )
+    return completed_process.stdout.strip()
+
+
+def _read_global_hooks_path(environment: dict[str, str]) -> str:
+    completed_process = subprocess.run(
+        ["git", "config", "--global", "--get", "core.hooksPath"],
+        capture_output=True,
+        text=True,
+        check=False,
+        env=environment,
+    )
+    return completed_process.stdout.strip()
+
+
+def _create_canonical_hooks_directory(home_directory: Path) -> Path:
+    canonical_hooks_directory = home_directory / ".claude" / "hooks" / "git-hooks"
+    canonical_hooks_directory.mkdir(parents=True)
+    return canonical_hooks_directory
+
+
+def test_should_remove_local_override_and_pass_preflight(tmp_path: Path) -> None:
+    home_directory = tmp_path / "home"
+    home_directory.mkdir()
+    environment = _make_isolated_git_environment(home_directory)
+    canonical_hooks_directory = _create_canonical_hooks_directory(home_directory)
+    _set_global_hooks_path(str(canonical_hooks_directory), environment)
+    repository_path = tmp_path / "synthetic-repo"
+    _initialize_repository(repository_path, environment)
+    stale_local_value = str(repository_path / ".git" / "hooks")
+    _set_local_hooks_path(repository_path, stale_local_value, environment)
+
+    exit_code = bugteam_fix_hookspath.main(
+        ["--repo-root", str(repository_path)],
+        environment_overrides=environment,
+    )
+
+    assert exit_code == 0, (
+        "fix script must succeed when canonical global hooks dir exists"
+    )
+    assert _read_local_hooks_path(repository_path, environment) == "", (
+        "local core.hooksPath override must be removed"
+    )
+
+
+def test_should_set_global_hooks_path_when_missing(tmp_path: Path) -> None:
+    home_directory = tmp_path / "home"
+    home_directory.mkdir()
+    environment = _make_isolated_git_environment(home_directory)
+    canonical_hooks_directory = _create_canonical_hooks_directory(home_directory)
+    repository_path = tmp_path / "synthetic-repo"
+    _initialize_repository(repository_path, environment)
+    stale_local_value = str(repository_path / ".git" / "hooks")
+    _set_local_hooks_path(repository_path, stale_local_value, environment)
+
+    exit_code = bugteam_fix_hookspath.main(
+        ["--repo-root", str(repository_path)],
+        environment_overrides=environment,
+    )
+
+    assert exit_code == 0
+    global_value_after_fix = _read_global_hooks_path(environment)
+    assert (
+        global_value_after_fix.replace("\\", "/")
+        .rstrip("/")
+        .endswith("hooks/git-hooks")
+    ), (
+        "fix script must set canonical global core.hooksPath when missing; "
+        f"got '{global_value_after_fix}'"
+    )
+
+
+def test_should_be_idempotent(tmp_path: Path) -> None:
+    home_directory = tmp_path / "home"
+    home_directory.mkdir()
+    environment = _make_isolated_git_environment(home_directory)
+    canonical_hooks_directory = _create_canonical_hooks_directory(home_directory)
+    _set_global_hooks_path(str(canonical_hooks_directory), environment)
+    repository_path = tmp_path / "synthetic-repo"
+    _initialize_repository(repository_path, environment)
+    stale_local_value = str(repository_path / ".git" / "hooks")
+    _set_local_hooks_path(repository_path, stale_local_value, environment)
+
+    first_exit_code = bugteam_fix_hookspath.main(
+        ["--repo-root", str(repository_path)],
+        environment_overrides=environment,
+    )
+    second_exit_code = bugteam_fix_hookspath.main(
+        ["--repo-root", str(repository_path)],
+        environment_overrides=environment,
+    )
+
+    assert first_exit_code == 0
+    assert second_exit_code == 0, "second invocation must succeed without errors"
+    assert _read_local_hooks_path(repository_path, environment) == ""
+
+
+def test_should_no_op_when_already_clean(tmp_path: Path) -> None:
+    home_directory = tmp_path / "home"
+    home_directory.mkdir()
+    environment = _make_isolated_git_environment(home_directory)
+    canonical_hooks_directory = _create_canonical_hooks_directory(home_directory)
+    _set_global_hooks_path(str(canonical_hooks_directory), environment)
+    repository_path = tmp_path / "synthetic-repo"
+    _initialize_repository(repository_path, environment)
+
+    exit_code = bugteam_fix_hookspath.main(
+        ["--repo-root", str(repository_path)],
+        environment_overrides=environment,
+    )
+
+    assert exit_code == 0
+    assert _read_local_hooks_path(repository_path, environment) == ""
+    assert (
+        _read_global_hooks_path(environment)
+        .replace("\\", "/")
+        .rstrip("/")
+        .endswith("hooks/git-hooks")
+    )
+
+
+def test_should_exit_nonzero_when_canonical_hooks_directory_missing(
+    tmp_path: Path,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    home_directory = tmp_path / "home"
+    home_directory.mkdir()
+    environment = _make_isolated_git_environment(home_directory)
+    repository_path = tmp_path / "synthetic-repo"
+    _initialize_repository(repository_path, environment)
+    stale_local_value = str(repository_path / ".git" / "hooks")
+    _set_local_hooks_path(repository_path, stale_local_value, environment)
+
+    exit_code = bugteam_fix_hookspath.main(
+        ["--repo-root", str(repository_path)],
+        environment_overrides=environment,
+    )
+
+    assert exit_code != 0, (
+        "fix script must fail clearly when ~/.claude/hooks/git-hooks does not exist "
+        "so the user knows to run `npx claude-dev-env .`"
+    )
+    captured_streams = capsys.readouterr()
+    assert "hooks/git-hooks" in captured_streams.err.replace("\\", "/")
+
+
+def test_should_handle_paths_with_spaces(tmp_path: Path) -> None:
+    home_directory = tmp_path / "home with space"
+    home_directory.mkdir()
+    environment = _make_isolated_git_environment(home_directory)
+    canonical_hooks_directory = _create_canonical_hooks_directory(home_directory)
+    _set_global_hooks_path(str(canonical_hooks_directory), environment)
+    repository_path = tmp_path / "repo with space"
+    _initialize_repository(repository_path, environment)
+    stale_local_value = str(repository_path / ".git" / "hooks")
+    _set_local_hooks_path(repository_path, stale_local_value, environment)
+
+    exit_code = bugteam_fix_hookspath.main(
+        ["--repo-root", str(repository_path)],
+        environment_overrides=environment,
+    )
+
+    assert exit_code == 0
+    assert _read_local_hooks_path(repository_path, environment) == ""