claude-dev-env 1.35.0 → 1.36.1

package/skills/bugteam/scripts/bugteam_fix_hookspath.py

@@ -1,260 +0,0 @@
-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/bugteam_preflight.py

@@ -1,201 +0,0 @@
-from __future__ import annotations
-
-import argparse
-import os
-import subprocess
-import sys
-from pathlib import Path
-
-
-def verify_git_hooks_path(repository_root: Path | None = 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.
-
-    Returns zero when the configured path ends with the expected hooks suffix.
-    Returns non-zero and prints a correction message when unset or pointing elsewhere.
-    """
-    expected_hooks_path_suffix = "hooks/git-hooks"
-    enforcement_absent_message = (
-        "Git-side CODE_RULES enforcement is not active on this host.\n"
-        "Run: npx claude-dev-env .\n"
-        "Or set core.hooksPath at any scope, e.g.:\n"
-        "  git config --global core.hooksPath ~/.claude/hooks/git-hooks"
-    )
-    git_command: list[str] = ["git"]
-    if repository_root is not None:
-        git_command.extend(["-C", str(repository_root)])
-    git_command.extend(["config", "--get", "core.hooksPath"])
-    try:
-        query_result = subprocess.run(
-            git_command,
-            capture_output=True,
-            text=True,
-            encoding="utf-8",
-            errors="replace",
-            check=False,
-        )
-    except FileNotFoundError:
-        print(
-            "bugteam_preflight: git is not installed or not available on PATH.\n"
-            f"{enforcement_absent_message}",
-            file=sys.stderr,
-        )
-        return 1
-    except OSError as os_error:
-        print(
-            f"bugteam_preflight: failed to run git: {os_error}\n"
-            f"{enforcement_absent_message}",
-            file=sys.stderr,
-        )
-        return 1
-    if query_result.returncode != 0:
-        print(
-            f"bugteam_preflight: {enforcement_absent_message}",
-            file=sys.stderr,
-        )
-        return 1
-    configured_path = query_result.stdout.strip().replace("\\", "/").rstrip("/")
-    if not configured_path.endswith(expected_hooks_path_suffix):
-        print(
-            f"bugteam_preflight: core.hooksPath is '{configured_path}' — "
-            f"expected path ending in '{expected_hooks_path_suffix}'.\n"
-            f"{enforcement_absent_message}",
-            file=sys.stderr,
-        )
-        return 1
-    return 0
-
-
-def find_repository_root(start: Path) -> Path:
-    resolved = start.resolve()
-    candidates = [resolved, *resolved.parents]
-    for candidate in candidates:
-        if (candidate / ".git").is_dir() or (candidate / ".git").is_file():
-            return candidate
-    for candidate in candidates:
-        if (candidate / "pytest.ini").is_file():
-            return candidate
-    return resolved
-
-
-def has_pytest_configuration(root: Path) -> bool:
-    if (root / "pytest.ini").is_file():
-        return True
-    pyproject = root / "pyproject.toml"
-    if not pyproject.is_file():
-        return False
-    text = pyproject.read_text(encoding="utf-8", errors="replace")
-    return "[tool.pytest" in text
-
-
-def has_discoverable_tests(root: Path) -> bool:
-    ignore = {"site-packages", ".venv", "venv", "node_modules"}
-    for path in root.rglob("test_*.py"):
-        if any(part in ignore for part in path.parts):
-            continue
-        return True
-    for path in root.rglob("*_test.py"):
-        if any(part in ignore for part in path.parts):
-            continue
-        return True
-    return False
-
-
-def _pytest_exit_code_no_tests_collected() -> int:
-    return 5
-
-
-def run_pytest(repository_root: Path, verbose: bool) -> int:
-    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:
-    completed = subprocess.run(
-        ["pre-commit", "run", "--all-files"],
-        cwd=str(repository_root),
-        check=False,
-    )
-    return completed.returncode
-
-
-def parse_arguments(argv: list[str]) -> argparse.Namespace:
-    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(argv)
-
-
-def main(argv: list[str] | None = None) -> int:
-    arguments = parse_arguments(sys.argv[1:] if argv is None else argv)
-    if os.environ.get("BUGTEAM_PREFLIGHT_SKIP", "").strip() == "1":
-        print("bugteam_preflight: skipped (BUGTEAM_PREFLIGHT_SKIP=1).", file=sys.stderr)
-        return 0
-    start = Path.cwd()
-    repository_root = (
-        arguments.repo_root.resolve()
-        if arguments.repo_root is not None
-        else find_repository_root(start)
-    )
-    hooks_path_exit_code = verify_git_hooks_path(repository_root)
-    if hooks_path_exit_code != 0:
-        return hooks_path_exit_code
-    if not arguments.no_pytest and has_pytest_configuration(repository_root):
-        if not has_discoverable_tests(repository_root):
-            print(
-                "bugteam_preflight: pytest configured but no tests found; skipping pytest.",
-                file=sys.stderr,
-            )
-        else:
-            exit_code = run_pytest(repository_root, arguments.verbose)
-            if exit_code != 0:
-                return exit_code
-    elif not arguments.no_pytest:
-        print(
-            "bugteam_preflight: no pytest configuration found; skipping pytest.",
-            file=sys.stderr,
-        )
-    if arguments.pre_commit and (repository_root / ".pre-commit-config.yaml").is_file():
-        exit_code = run_pre_commit(repository_root)
-        if exit_code != 0:
-            return exit_code
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())

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

@@ -1,17 +0,0 @@
-"""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/grant_project_claude_permissions.py

@@ -1,109 +0,0 @@
-"""Grant Edit/Write/Read permissions on the current directory's .claude tree.
-
-Run from the project root whose .claude/** you want a Claude Code session
-(including spawned subagents) to edit without prompting. Writes idempotent
-entries into the user-scope settings at ~/.claude/settings.json and prints
-the changes applied. No-op when the entries already exist.
-"""
-
-import sys
-from pathlib import Path
-
-sys.path.insert(0, str(Path(__file__).resolve().parent))
-
-from _claude_permissions_common import (  # noqa: E402
-    append_if_missing,
-    build_permission_rules,
-    ensure_dict_section,
-    ensure_list_entry,
-    exit_with_error,
-    get_current_project_path,
-    load_settings,
-    save_settings,
-    AUTO_MODE_ENVIRONMENT_ENTRY_TEMPLATE,
-    PERMISSION_ALLOW_TOOLS,
-)
-
-
-def is_valid_project_root(candidate_path: Path) -> bool:
-    git_marker_path = candidate_path / ".git"
-    claude_marker_path = candidate_path / ".claude"
-    return git_marker_path.exists() or claude_marker_path.exists()
-
-
-def add_rules_to_allow_list(settings: dict[str, object], rules_to_add: list[str]) -> int:
-    permissions_section = ensure_dict_section(settings, "permissions")
-    existing_allow_list = ensure_list_entry(permissions_section, "allow")
-    return sum(
-        1
-        for each_rule in rules_to_add
-        if append_if_missing(existing_allow_list, each_rule)
-    )
-
-
-def add_directory_to_additional_directories(
-    settings: dict[str, object], directory_path: str
-) -> int:
-    permissions_section = ensure_dict_section(settings, "permissions")
-    existing_directories = ensure_list_entry(
-        permissions_section, "additionalDirectories"
-    )
-    if append_if_missing(existing_directories, directory_path):
-        return 1
-    return 0
-
-
-def add_auto_mode_environment_entry(
-    settings: dict[str, object], entry_text: str
-) -> int:
-    auto_mode_section = ensure_dict_section(settings, "autoMode")
-    existing_environment = ensure_list_entry(auto_mode_section, "environment")
-    if append_if_missing(existing_environment, entry_text):
-        return 1
-    return 0
-
-
-def grant_permissions_for_current_directory() -> None:
-    claude_user_settings_path: Path = Path.home() / ".claude" / "settings.json"
-    project_root_path = Path.cwd()
-    if not is_valid_project_root(project_root_path):
-        print(
-            f"ERROR: cwd {project_root_path} is not a project root "
-            f"(no .git or .claude). Run from a project root.",
-            file=sys.stderr,
-        )
-        raise SystemExit(1)
-    project_path = get_current_project_path()
-    permission_rules = build_permission_rules(project_path, PERMISSION_ALLOW_TOOLS)
-    environment_entry = AUTO_MODE_ENVIRONMENT_ENTRY_TEMPLATE.format(
-        project_path=project_path
-    )
-    settings = load_settings(claude_user_settings_path)
-    rules_added_count = add_rules_to_allow_list(settings, permission_rules)
-    directories_added_count = add_directory_to_additional_directories(
-        settings, project_path
-    )
-    environment_entries_added_count = add_auto_mode_environment_entry(
-        settings, environment_entry
-    )
-    total_changes_count = (
-        rules_added_count + directories_added_count + environment_entries_added_count
-    )
-    if total_changes_count == 0:
-        print(f"Project path: {project_path}")
-        print(f"Settings file: {claude_user_settings_path}")
-        print("No changes needed; settings file left untouched.")
-        return
-    save_settings(claude_user_settings_path, settings)
-    print(f"Project path: {project_path}")
-    print(f"Settings file: {claude_user_settings_path}")
-    print(f"Allow rules added: {rules_added_count} of {len(permission_rules)}")
-    print(f"Additional directories added: {directories_added_count}")
-    print(f"Auto-mode environment entries added: {environment_entries_added_count}")
-
-
-if __name__ == "__main__":
-    try:
-        grant_permissions_for_current_directory()
-    except ValueError as path_error:
-        exit_with_error(str(path_error))